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

­Y (=>)

The truth-functional connective of implication.

Ontology

SUMO / STRUCTURAL-ONTOLOGY

Class(es)

ÅÞ¿è¹Bºâ¤¸
is instance of
  ­Y  

Coordinate term(s)

­Y¥B°ß­Y  ©M  ±Àª¾  ¦s¦b  ©Ò¦³  «D  ©Î 

Type restrictions

=>(SUO-KIFªí­z¦¡, SUO-KIFªí­z¦¡)

Related WordNet synsets

See more related synsets on a separate page.

Axioms (679)

If entity ¬O class ªº ª½±µ ¹ê¨Ò, then there doesn't exist class subclass so that entity ¬O subclass ªº ¹ê¨Ò.
(=>
      (immediateInstance ?ENTITY ?CLASS)
      (not
            (exists
                  (?SUBCLASS)
                  (and
                        (subclass ?SUBCLASS ?CLASS)
                        (instance ?ENTITY ?SUBCLASS)))))

If rel1 ¬O rel2 ªº ­Ë§Ç, then for all inst1,inst2 holds: rel1(inst1,inst2) (¤£) ¦¨¥ßs if and only if rel2(inst2,inst1) (¤£) ¦¨¥ßs.
(=>
      (inverse ?REL1 ?REL2)
      (forall
            (?INST1 ?INST2)
            (<=>
                  (holds ?REL1 ?INST1 ?INST2)
                  (holds ?REL2 ?INST2 ?INST1))))

subclass ¬O class ªº ¦¸ºØÃþ if and only if
(<=>
      (subclass ?SUBCLASS ?CLASS)
      (and
            (instance ?SUBCLASS SetOrClass)
            (instance ?CLASS SetOrClass)
            (forall
                  (?INST)
                  (=>
                        (instance ?INST ?SUBCLASS)
                        (instance ?INST ?CLASS)))))

If class1 ¬O class2 ªº ª½±µ ¦¸ºØÃþ, then there doesn't exist class2 class3 so that class1 ¬O class3 ªº ¦¸ºØÃþ and class2 µ¥©ó class3 and class1 µ¥©ó class3.
(=>
      (immediateSubclass ?CLASS1 ?CLASS2)
      (not
            (exists
                  (?CLASS3)
                  (and
                        (subclass ?CLASS3 ?CLASS2)
                        (subclass ?CLASS1 ?CLASS3)
                        (not
                              (equal ?CLASS2 ?CLASS3))
                        (not
                              (equal ?CLASS1 ?CLASS3))))))

If pred1 ¬O pred2 ªº ¦¸Ãö«Y and pred1 %&¦³ ½×¤¸(s) number, then pred2 %&¦³ ½×¤¸(s) number.
(=>
      (and
            (subrelation ?PRED1 ?PRED2)
            (valence ?PRED1 ?NUMBER))
      (valence ?PRED2 ?NUMBER))

If pred1 ¬O pred2 ªº ¦¸Ãö«Y and pred2 ªº ½×¤¸ number ¬O class1 ªº ¹ê¨Ò, then pred1 ªº ½×¤¸ number ¬O class1 ªº ¹ê¨Ò.
(=>
      (and
            (subrelation ?PRED1 ?PRED2)
            (domain ?PRED2 ?NUMBER ?CLASS1))
      (domain ?PRED1 ?NUMBER ?CLASS1))

If rel1 ¬O rel2 ªº ¦¸Ãö«Y and rel1() (¤£) ¦¨¥ßs, then rel2() (¤£) ¦¨¥ßs.
(=>
      (and
            (subrelation ?REL1 ?REL2)
            (holds ?REL1 @ROW))
      (holds ?REL2 @ROW))

If pred1 ¬O pred2 ªº ¦¸Ãö«Y and pred2 ¬O class ªº ¹ê¨Ò and class ¬O ¥iÄ~©ÓÃö«Y ªº ¹ê¨Ò, then pred1 ¬O class ªº ¹ê¨Ò.
(=>
      (and
            (subrelation ?PRED1 ?PRED2)
            (instance ?PRED2 ?CLASS)
            (instance ?CLASS InheritableRelation))
      (instance ?PRED1 ?CLASS))

If rel ªº ½×¤¸ number ¬O class1 ªº ¹ê¨Ò and rel ªº ½×¤¸ number ¬O class2 ªº ¹ê¨Ò, then class1 ¬O class2 ªº ¦¸ºØÃþ or class2 ¬O class1 ªº ¦¸ºØÃþ.
(=>
      (and
            (domain ?REL ?NUMBER ?CLASS1)
            (domain ?REL ?NUMBER ?CLASS2))
      (or
            (subclass ?CLASS1 ?CLASS2)
            (subclass ?CLASS2 ?CLASS1)))

If rel1 ¬O rel2 ªº ¦¸Ãö«Y and rel2 ªº ½×¤¸ number ¬O class1 ªº ¦¸ºØÃþ, then rel1 ªº ½×¤¸ number ¬O class1 ªº ¦¸ºØÃþ.
(=>
      (and
            (subrelation ?REL1 ?REL2)
            (domainSubclass ?REL2 ?NUMBER ?CLASS1))
      (domainSubclass ?REL1 ?NUMBER ?CLASS1))

If rel ªº ½×¤¸ number ¬O class1 ªº ¦¸ºØÃþ and rel ªº ½×¤¸ number ¬O class2 ªº ¦¸ºØÃþ, then class1 ¬O class2 ªº ¦¸ºØÃþ or class2 ¬O class1 ªº ¦¸ºØÃþ.
(=>
      (and
            (domainSubclass ?REL ?NUMBER ?CLASS1)
            (domainSubclass ?REL ?NUMBER ?CLASS2))
      (or
            (subclass ?CLASS1 ?CLASS2)
            (subclass ?CLASS2 ?CLASS1)))

If thing1 µ¥©ó thing2, then for all attr holds: thing1 ¦³ ÄÝ©Ê attr if and only if thing2 ¦³ ÄÝ©Ê attr.
(=>
      (equal ?THING1 ?THING2)
      (forall
            (?ATTR)
            (<=>
                  (property ?THING1 ?ATTR)
                  (property ?THING2 ?ATTR))))

If attr1 µ¥©ó attr2, then for all thing holds: thing ¦³ ÄÝ©Ê attr1 if and only if thing ¦³ ÄÝ©Ê attr2.
(=>
      (equal ?ATTR1 ?ATTR2)
      (forall
            (?THING)
            (<=>
                  (property ?THING ?ATTR1)
                  (property ?THING ?ATTR2))))

If thing1 µ¥©ó thing2, then for all class holds: thing1 ¬O class ªº ¹ê¨Ò if and only if thing2 ¬O class ªº ¹ê¨Ò.
(=>
      (equal ?THING1 ?THING2)
      (forall
            (?CLASS)
            (<=>
                  (instance ?THING1 ?CLASS)
                  (instance ?THING2 ?CLASS))))

If class1 µ¥©ó class2, then for all thing holds: thing ¬O class1 ªº ¹ê¨Ò if and only if thing ¬O class2 ªº ¹ê¨Ò.
(=>
      (equal ?CLASS1 ?CLASS2)
      (forall
            (?THING)
            (<=>
                  (instance ?THING ?CLASS1)
                  (instance ?THING ?CLASS2))))

If rel1 µ¥©ó rel2, then for all holds: rel1() (¤£) ¦¨¥ßs if and only if rel2() (¤£) ¦¨¥ßs.
(=>
      (equal ?REL1 ?REL2)
      (forall
            (@ROW)
            (<=>
                  (holds ?REL1 @ROW)
                  (holds ?REL2 @ROW))))

(=>
      (equal ?OBJ1 ?OBJ2)
      (=>
            (and
                  (equal
                        ?OBJ1
                        (ListOrderFn
                              (ListFn @ROW1)
                              ?NUMBER))
                  (equal
                        ?OBJ2
                        (ListOrderFn
                              (ListFn @ROW2)
                              ?NUMBER))
                  (equal
                        (ListFn @ROW1)
                        (ListFn @ROW2)))
            (<=>
                  (holds @ROW1)
                  (holds @ROW2))))

(=>
      (equal ?LIST1 ?LIST2)
      (=>
            (and
                  (equal
                        ?LIST1
                        (ListFn @ROW1))
                  (equal
                        ?LIST2
                        (ListFn @ROW2)))
            (forall
                  (?NUMBER)
                  (equal
                        (ListOrderFn
                              (ListFn @ROW1)
                              ?NUMBER)
                        (ListOrderFn
                              (ListFn @ROW2)
                              ?NUMBER)))))

If function ªº ½d³ò ¬O class ªº ¹ê¨Ò and "function()" µ¥©ó value, then value ¬O class ªº ¹ê¨Ò.
(=>
      (and
            (range ?FUNCTION ?CLASS)
            (equal
                  (AssignmentFn ?FUNCTION @ROW)
                  ?VALUE))
      (instance ?VALUE ?CLASS))

If rel1 ¬O rel2 ªº ¦¸Ãö«Y and rel2 ªº ½d³ò ¬O class1 ªº ¹ê¨Ò, then rel1 ªº ½d³ò ¬O class1 ªº ¹ê¨Ò.
(=>
      (and
            (subrelation ?REL1 ?REL2)
            (range ?REL2 ?CLASS1))
      (range ?REL1 ?CLASS1))

If rel ªº ½d³ò ¬O class1 ªº ¹ê¨Ò and rel ªº ½d³ò ¬O class2 ªº ¹ê¨Ò, then class1 ¬O class2 ªº ¦¸ºØÃþ or class2 ¬O class1 ªº ¦¸ºØÃþ.
(=>
      (and
            (range ?REL ?CLASS1)
            (range ?REL ?CLASS2))
      (or
            (subclass ?CLASS1 ?CLASS2)
            (subclass ?CLASS2 ?CLASS1)))

If ³Q function Âk¦^ ªº­È ¬O classªº ¦¸ºØÃþ and "function()" µ¥©ó value, then value ¬O class ªº ¦¸ºØÃþ.
(=>
      (and
            (rangeSubclass ?FUNCTION ?CLASS)
            (equal
                  (AssignmentFn ?FUNCTION @ROW)
                  ?VALUE))
      (subclass ?VALUE ?CLASS))

If rel1 ¬O rel2 ªº ¦¸Ãö«Y and ³Q rel2 Âk¦^ ªº­È ¬O class1ªº ¦¸ºØÃþ, then ³Q rel1 Âk¦^ ªº­È ¬O class1ªº ¦¸ºØÃþ.
(=>
      (and
            (subrelation ?REL1 ?REL2)
            (rangeSubclass ?REL2 ?CLASS1))
      (rangeSubclass ?REL1 ?CLASS1))

If ³Q rel Âk¦^ ªº­È ¬O class1ªº ¦¸ºØÃþ and ³Q rel Âk¦^ ªº­È ¬O class2ªº ¦¸ºØÃþ, then class1 ¬O class2 ªº ¦¸ºØÃþ or class2 ¬O class1 ªº ¦¸ºØÃþ.
(=>
      (and
            (rangeSubclass ?REL ?CLASS1)
            (rangeSubclass ?REL ?CLASS2))
      (or
            (subclass ?CLASS1 ?CLASS2)
            (subclass ?CLASS2 ?CLASS1)))

If µL¥æ¶°Ãö«Y() holds and rel ¬O "()" ªº ¤@ ¦¨­û, then rel ¬O Ãö«Y ªº ¹ê¨Ò.
(=>
      (and
            (disjointRelation @ROW)
            (inList
                  ?REL
                  (ListFn @ROW)))
      (instance ?REL Relation))

If µL¥æ¶°Ãö«Y() holds and rel1 ¬O "()" ªº ¤@ ¦¨­û and rel2 ¬O "()" ªº ¤@ ¦¨­û and rel1 %&¦³ ½×¤¸(s) number, then rel2 %&¦³ ½×¤¸(s) number.
(=>
      (and
            (disjointRelation @ROW)
            (inList
                  ?REL1
                  (ListFn @ROW))
            (inList
                  ?REL2
                  (ListFn @ROW))
            (valence ?REL1 ?NUMBER))
      (valence ?REL2 ?NUMBER))

If rel1 ªº ½×¤¸ number ¬O class1 ªº ¹ê¨Ò and rel2 ªº ½×¤¸ number ¬O class2 ªº ¹ê¨Ò and class1 µL¥æ¶° ©ó class2, then µL¥æ¶°Ãö«Y(rel1,rel2) holds.
(=>
      (and
            (domain ?REL1 ?NUMBER ?CLASS1)
            (domain ?REL2 ?NUMBER ?CLASS2)
            (disjoint ?CLASS1 ?CLASS2))
      (disjointRelation ?REL1 ?REL2))

If rel1 ªº ½×¤¸ number ¬O class1 ªº ¦¸ºØÃþ and rel2 ªº ½×¤¸ number ¬O class2 ªº ¦¸ºØÃþ and class1 µL¥æ¶° ©ó class2, then µL¥æ¶°Ãö«Y(rel1,rel2) holds.
(=>
      (and
            (domainSubclass ?REL1 ?NUMBER ?CLASS1)
            (domainSubclass ?REL2 ?NUMBER ?CLASS2)
            (disjoint ?CLASS1 ?CLASS2))
      (disjointRelation ?REL1 ?REL2))

If rel1 ªº ½d³ò ¬O class1 ªº ¹ê¨Ò and rel2 ªº ½d³ò ¬O class2 ªº ¹ê¨Ò and class1 µL¥æ¶° ©ó class2, then µL¥æ¶°Ãö«Y(rel1,rel2) holds.
(=>
      (and
            (range ?REL1 ?CLASS1)
            (range ?REL2 ?CLASS2)
            (disjoint ?CLASS1 ?CLASS2))
      (disjointRelation ?REL1 ?REL2))

If ³Q rel1 Âk¦^ ªº­È ¬O class1ªº ¦¸ºØÃþ and ³Q rel2 Âk¦^ ªº­È ¬O class2ªº ¦¸ºØÃþ and class1 µL¥æ¶° ©ó class2, then µL¥æ¶°Ãö«Y(rel1,rel2) holds.
(=>
      (and
            (rangeSubclass ?REL1 ?CLASS1)
            (rangeSubclass ?REL2 ?CLASS2)
            (disjoint ?CLASS1 ?CLASS2))
      (disjointRelation ?REL1 ?REL2))

If µL¥æ¶°Ãö«Y() holds and rel1 ¬O "()" ªº ¤@ ¦¨­û and rel2 ¬O "()" ªº ¤@ ¦¨­û and rel1 µ¥©ó rel2 and rel1() (¤£) ¦¨¥ßs, then rel2() not(¤£) ¦¨¥ß.
(=>
      (and
            (disjointRelation @ROW1)
            (inList
                  ?REL1
                  (ListFn @ROW1))
            (inList
                  ?REL2
                  (ListFn @ROW1))
            (not
                  (equal ?REL1 ?REL2))
            (holds ?REL1 @ROW2))
      (not
            (holds ?REL2 @ROW2)))

(=>
      (contraryAttribute @ROW)
      (=>
            (inList
                  ?ELEMENT
                  (ListFn @ROW))
            (instance ?ELEMENT Attribute)))

(=>
      (contraryAttribute @ROW)
      (forall
            (?ATTR1 ?ATTR2)
            (=>
                  (and
                        (equal
                              ?ATTR1
                              (ListOrderFn
                                    (ListFn @ROW)
                                    ?NUMBER1))
                        (equal
                              ?ATTR2
                              (ListOrderFn
                                    (ListFn @ROW)
                                    ?NUMBER2))
                        (not
                              (equal ?NUMBER1 ?NUMBER2)))
                  (=>
                        (property ?OBJ ?ATTR1)
                        (not
                              (property ?OBJ ?ATTR2))))))

(=>
      (exhaustiveAttribute ?CLASS @ROW)
      (=>
            (inList
                  ?ATTR
                  (ListFn @ROW))
            (instance ?ATTR Attribute)))

(=>
      (exhaustiveAttribute ?CLASS @ROW)
      (forall
            (?OBJ)
            (=>
                  (instance ?ATTR1 ?CLASS)
                  (exists
                        (?ATTR2)
                        (and
                              (inList
                                    ?ATTR2
                                    (ListFn @ROW))
                              (equal ?ATTR1 ?ATTR2))))))

(=>
      (exhaustiveDecomposition @ROW)
      (=>
            (inList
                  ?ELEMENT
                  (ListFn @ROW))
            (instance ?ELEMENT Class)))

(=>
      (disjointDecomposition @ROW)
      (=>
            (inList
                  ?ELEMENT
                  (ListFn @ROW))
            (instance ?ELEMENT Class)))

(=>
      (subAttribute ?ATTR1 ?ATTR2)
      (forall
            (?OBJ)
            (=>
                  (property ?OBJ ?ATTR1)
                  (property ?OBJ ?ATTR2))))

If attr1 ¬O attr2 ªº ¦¸ÄÝ©Ê and attr2 ¬O class ªº ¹ê¨Ò, then attr1 ¬O class ªº ¹ê¨Ò.
(=>
      (and
            (subAttribute ?ATTR1 ?ATTR2)
            (instance ?ATTR2 ?CLASS))
      (instance ?ATTR1 ?CLASS))

If attr1 ¬O attr2 ªº Äò±µÄÝ©Ê and entity ¦³ ÄÝ©Ê attr2 time1a(¤§¤¤) time1, then there exists time2 so that time2 ¬O "time1 ¤§«e" ªº ³¡¤À and entity ¦³ ÄÝ©Ê attr1 time2a(¤§¤¤) time2.
(=>
      (and
            (successorAttribute ?ATTR1 ?ATTR2)
            (holdsDuring
                  ?TIME1
                  (property ?ENTITY ?ATTR2)))
      (exists
            (?TIME2)
            (and
                  (temporalPart
                        ?TIME2
                        (PastFn ?TIME1))
                  (holdsDuring
                        ?TIME2
                        (property ?ENTITY ?ATTR1)))))

If attr1 ¬O attr2 ªº Äò±µÄÝ©Ê, then attr1 ¬O attr2 ªº «Ê³¬Äò±µÄÝ©Ê.
(=>
      (successorAttribute ?ATTR1 ?ATTR2)
      (successorAttributeClosure ?ATTR1 ?ATTR2))

If rel(,inst) (¤£) ¦¨¥ßs and rel ¬O ¨ç¼Æ ªº ¹ê¨Ò, then "rel()" µ¥©ó inst.
(=>
      (and
            (holds ?REL @ROW ?INST)
            (instance ?REL Function))
      (equal
            (AssignmentFn ?REL @ROW)
            ?INST))

If class ¬O ºØÃþ ªº ¹ê¨Ò, then class ¬O ¹êÅé ªº ¦¸ºØÃþ.
(=>
      (instance ?CLASS Class)
      (subclass ?CLASS Entity))

If obj ¬O ¦Û¨­³sÄòª«Åé ªº ¹ê¨Ò, then "obj ªº ¥¿­±" ¬O obj ªº ³¡¤À).
(=>
      (instance ?OBJ SelfConnectedObject)
      (part
            (FrontFn ?OBJ)
            ?OBJ))

If obj ¬O ¦Û¨­³sÄòª«Åé ªº ¹ê¨Ò, then "obj ªº ¤Ï­±" ¬O obj ªº ³¡¤À).
(=>
      (instance ?OBJ SelfConnectedObject)
      (part
            (BackFn ?OBJ)
            ?OBJ))

(=>
      (piece ?SUBSTANCE1 ?SUBSTANCE2)
      (forall
            (?CLASS)
            (=>
                  (instance ?SUBSTANCE1 ?CLASS)
                  (instance ?SUBSTANCE2 ?CLASS))))

If objecttype ¬O ª«½è ªº ¦¸ºØÃþ and object ¬O objecttype ªº ¹ê¨Ò and part ¬O object ªº ³¡¤À), then part ¬O objecttype ªº ¹ê¨Ò.
(=>
      (and
            (subclass ?OBJECTTYPE Substance)
            (instance ?OBJECT ?OBJECTTYPE)
            (part ?PART ?OBJECT))
      (instance ?PART ?OBJECTTYPE))

If obj ¬O ª«½è ªº ¹ê¨Ò and attr ¬O obj ªº ÄÝ©Ê and part ¬O obj ªº ³¡¤À), then attr ¬O part ªº ÄÝ©Ê.
(=>
      (and
            (instance ?OBJ Substance)
            (attribute ?OBJ ?ATTR)
            (part ?PART ?OBJ))
      (attribute ?PART ?ATTR))

If atom ¬O ­ì¤l ªº ¹ê¨Ò, then there exist ½è¤l proton,¹q¤l electron so that proton ¬O atom ªº ¤¸¥ó and electron ¬O atom ªº ¤¸¥ó.
(=>
      (instance ?ATOM Atom)
      (exists
            (?PROTON ?ELECTRON)
            (and
                  (component ?PROTON ?ATOM)
                  (component ?ELECTRON ?ATOM)
                  (instance ?PROTON Proton)
                  (instance ?ELECTRON Electron))))

(=>
      (instance ?ATOM Atom)
      (forall
            (?NUCLEUS1 ?NUCLEUS2)
            (=>
                  (and
                        (component ?NUCLEUS1 ?ATOM)
                        (component ?NUCLEUS2 ?ATOM)
                        (instance ?NUCLEUS1 AtomicNucleus)
                        (instance ?NUCLEUS2 AtomicNucleus))
                  (equal ?NUCLEUS1 ?NUCLEUS2))))

If particle ¬O ¦¸­ì¤l²É¤l ªº ¹ê¨Ò, then there exists ­ì¤l atom so that particle ¬O atom ªº ³¡¤À).
(=>
      (instance ?PARTICLE SubatomicParticle)
      (exists
            (?ATOM)
            (and
                  (instance ?ATOM Atom)
                  (part ?PARTICLE ?ATOM))))

If nucleus ¬O ­ì¤l®Ö ªº ¹ê¨Ò, then there exist ¤¤¤l neutron,½è¤l proton so that neutron ¬O nucleus ªº ¤¸¥ó and proton ¬O nucleus ªº ¤¸¥ó.
(=>
      (instance ?NUCLEUS AtomicNucleus)
      (exists
            (?NEUTRON ?PROTON)
            (and
                  (component ?NEUTRON ?NUCLEUS)
                  (component ?PROTON ?NUCLEUS)
                  (instance ?NEUTRON Neutron)
                  (instance ?PROTON Proton))))

If mixture ¬O ²V¦Xª« ªº ¹ê¨Ò, then there exist ¯Âª«½è pure1,¯Âª«½è pure2 so that pure1 µ¥©ó pure2 and pure1 ¬O mixture ªº ¤@¤p³¡¤À and pure2 ¬O mixture ªº ¤@¤p³¡¤À.
(=>
      (instance ?MIXTURE Mixture)
      (exists
            (?PURE1 ?PURE2)
            (and
                  (subclass ?PURE1 PureSubstance)
                  (subclass ?PURE2 PureSubstance)
                  (not
                        (equal ?PURE1 ?PURE2))
                  (piece ?PURE1 ?MIXTURE)
                  (piece ?PURE2 ?MIXTURE))))

If obj ¬O ½ÆÂøÅé/«D³æ½èÅé ªº ¹ê¨Ò, then there exist ª«½è substance1,ª«½è substance2 so that substance1 ¬O ¥Ñ obj ²Õ¦¨ and substance2 ¬O ¥Ñ obj ²Õ¦¨ and substance1 µ¥©ó substance2.
(=>
      (instance ?OBJ CorpuscularObject)
      (exists
            (?SUBSTANCE1 ?SUBSTANCE2)
            (and
                  (subclass ?SUBSTANCE1 Substance)
                  (subclass ?SUBSTANCE2 Substance)
                  (material ?SUBSTANCE1 ?OBJ)
                  (material ?SUBSTANCE2 ?OBJ)
                  (not
                        (equal ?SUBSTANCE1 ?SUBSTANCE2)))))

If region ¬O °Ï°ì ªº ¹ê¨Ò, then there exists phys so that phys ¦ì©ó region.
(=>
      (instance ?REGION Region)
      (exists
            (?PHYS)
            (located ?PHYS ?REGION)))

If coll ¬O ¸s¶° ªº ¹ê¨Ò, then there exists obj so that obj ¬O collªº ¦¨­û.
(=>
      (instance ?COLL Collection)
      (exists
            (?OBJ)
            (member ?OBJ ?COLL)))

coll1 ¬O coll2 ªº ¥¿ ¦¸»E¶° if and only if
(<=>
      (subCollection ?COLL1 ?COLL2)
      (and
            (instance ?COLL1 Collection)
            (instance ?COLL2 Collection)
            (forall
                  (?MEMBER)
                  (=>
                        (member ?MEMBER ?COLL1)
                        (member ?MEMBER ?COLL2)))))

If string ¬O ²Å¸¹¦ê ªº ¹ê¨Ò, then there exists ¦r¤¸ part so that part ¬O string ªº ³¡¤À).
(=>
      (instance ?STRING SymbolicString)
      (exists
            (?PART)
            (and
                  (part ?PART ?STRING)
                  (instance ?PART Character))))

If lang ¬O °Êª«»y¨¥ ªº ¹ê¨Ò and proc ¬O agent ªº ¬I¨ÆªÌ and lang ¹ï proc ¬O ¤u¨ã, then agent ¬O °Êª« ªº ¹ê¨Ò and agent ¬O ¤HÃþ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?LANG AnimalLanguage)
            (agent ?PROC ?AGENT)
            (instrument ?PROC ?LANG))
      (and
            (instance ?AGENT Animal)
            (not
                  (instance ?AGENT Human))))

If lang ¬O ¹q¸£»y¨¥ ªº ¹ê¨Ò and proc ¬O agent ªº ¬I¨ÆªÌ and lang ¹ï proc ¬O ¤u¨ã, then agent ¬O ¾÷¾¹ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?LANG ComputerLanguage)
            (agent ?PROC ?AGENT)
            (instrument ?PROC ?LANG))
      (instance ?AGENT Machine))

If lang ¬O ¤HÃþ»y¨¥ ªº ¹ê¨Ò and proc ¬O agent ªº ¬I¨ÆªÌ and lang ¹ï proc ¬O ¤u¨ã, then agent ¬O ¤HÃþ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?LANG HumanLanguage)
            (agent ?PROC ?AGENT)
            (instrument ?PROC ?LANG))
      (instance ?AGENT Human))

If lang ¬O ¤H³y»y¨¥ ªº ¹ê¨Ò, then there exists ­pµe plan so that lang ¬O plan ªº µ²ªG.
(=>
      (instance ?LANG ConstructedLanguage)
      (exists
            (?PLAN)
            (and
                  (instance ?PLAN Planning)
                  (result ?PLAN ?LANG))))

If process ¬O Âù¨ü¨Æ¾úµ{ ªº ¹ê¨Ò, then there exist obj1,obj2 so that obj1 ¬O process ªº ¨ü¨ÆªÌ and obj2 ¬O process ªº ¨ü¨ÆªÌ and obj1 µ¥©ó obj2.
(=>
      (instance ?PROCESS DualObjectProcess)
      (exists
            (?OBJ1 ?OBJ2)
            (and
                  (patient ?PROCESS ?OBJ1)
                  (patient ?PROCESS ?OBJ2)
                  (not
                        (equal ?OBJ1 ?OBJ2)))))

If number ¬O µê¼Æ ªº ¹ê¨Ò, then there exists ¹ê¼Æ real so that number µ¥©ó "real*" ªº ¥­¤è®Ú"".
(=>
      (instance ?NUMBER ImaginaryNumber)
      (exists
            (?REAL)
            (and
                  (instance ?REAL RealNumber)
                  (equal
                        ?NUMBER
                        (MultiplicationFn
                              ?REAL
                              (SquareRootFn -1))))))

If number ¬O ½Æ¼Æ ªº ¹ê¨Ò, then there exist ¹ê¼Æ real1,¹ê¼Æ real2 so that number µ¥©ó "(real1+"real2*" ªº ¥­¤è®Ú"")".
(=>
      (instance ?NUMBER ComplexNumber)
      (exists
            (?REAL1 ?REAL2)
            (and
                  (instance ?REAL1 RealNumber)
                  (instance ?REAL2 RealNumber)
                  (equal
                        ?NUMBER
                        (AdditionFn
                              ?REAL1
                              (MultiplicationFn
                                    ?REAL2
                                    (SquareRootFn -1)))))))

If function ¬O ¤@¤¸«í©w¨ç¼Æ¶q ªº ¹ê¨Ò, then function ªº ½×¤¸ ¬O ±`¶q ªº ¹ê¨Ò and function ªº ½d³ò ¬O ±`¶q ªº ¹ê¨Ò.
(=>
      (instance ?FUNCTION UnaryConstantFunctionQuantity)
      (and
            (domain ?FUNCTION 1 ConstantQuantity)
            (range ?FUNCTION ConstantQuantity)))

If function ¬O ®É¶¡¨ÌÅܶq ªº ¹ê¨Ò, then function ªº ½×¤¸ ¬O ®É¶¡³æ¦ì ªº ¹ê¨Ò.
(=>
      (instance ?FUNCTION TimeDependentQuantity)
      (domain ?FUNCTION 1 TimeMeasure))

If rel ¬O Ãö«Y ªº ¹ê¨Ò, then rel() (¤£) ¦¨¥ßs if and only if rel() holds.
(=>
      (instance ?REL Relation)
      (<=>
            (holds ?REL @ROW)
            (?REL @ROW)))

rel ¬O ³æ­ÈÃö«Y ªº ¹ê¨Ò if and only if for all ,item1,item2 holds: if rel(,item1) (¤£) ¦¨¥ßs and rel(,item2) (¤£) ¦¨¥ßs, then item1 µ¥©ó item2.
(<=>
      (instance ?REL SingleValuedRelation)
      (forall
            (@ROW ?ITEM1 ?ITEM2)
            (=>
                  (and
                        (holds ?REL @ROW ?ITEM1)
                        (holds ?REL @ROW ?ITEM2))
                  (equal ?ITEM1 ?ITEM2))))

rel ¬O ¥þ­ÈÃö«Y ªº ¹ê¨Ò if and only if there exists valence so that rel ¬O Ãö«Y ªº ¹ê¨Ò and rel %&¦³ ½×¤¸(s) valence and
(<=>
      (instance ?REL TotalValuedRelation)
      (exists
            (?VALENCE)
            (and
                  (instance ?REL Relation)
                  (valence ?REL ?VALENCE)
                  (=>
                        (forall
                              (?NUMBER ?ELEMENT ?CLASS)
                              (=>
                                    (and
                                          (lessThan ?NUMBER ?VALENCE)
                                          (domain ?REL ?NUMBER ?CLASS)
                                          (equal
                                                ?ELEMENT
                                                (ListOrderFn
                                                      (ListFn @ROW)
                                                      ?NUMBER)))
                                    (instance ?ELEMENT ?CLASS)))
                        (exists
                              (?ITEM)
                              (holds ?REL @ROW ?ITEM))))))

If rel ¬O ¤G¤¸Ãö«Y ªº ¹ê¨Ò, then there don't exist item1,item2,item3, so that rel(item1,item2,item3,) (¤£) ¦¨¥ßs.
(=>
      (instance ?REL BinaryRelation)
      (not
            (exists
                  (?ITEM1 ?ITEM2 ?ITEM3 @ROW)
                  (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 @ROW))))

(=>
      (instance ?REL ReflexiveRelation)
      (=>
            (or
                  (holds ?REL ?INST1 ?INST2)
                  (holds ?REL ?INST2 ?INST1))
            (holds ?REL ?INST1 ?INST1)))

If rel ¬O «D¤Ï¨­Ãö«Y ªº ¹ê¨Ò, then for all inst holds: rel(inst,inst) not(¤£) ¦¨¥ß.
(=>
      (instance ?REL IrreflexiveRelation)
      (forall
            (?INST)
            (not
                  (holds ?REL ?INST ?INST))))

(=>
      (instance ?REL SymmetricRelation)
      (forall
            (?INST1 ?INST2)
            (=>
                  (holds ?REL ?INST1 ?INST2)
                  (holds ?REL ?INST2 ?INST1))))

If , then rel ¬O ¤£¹ïºÙÃö«Y ªº ¹ê¨Ò.
(=>
      (and
            (instance ?REL BinaryRelation)
            (or
                  (domain ?REL 1 ?CLASS1)
                  (domainSubclass ?REL 1 ?CLASS1))
            (or
                  (domain ?REL 2 ?CLASS2)
                  (domainSubclass ?REL 2 ?CLASS2)
                  (range ?REL ?CLASS2)
                  (rangeSubclass ?REL ?CLASS2))
            (disjoint ?CLASS1 ?CLASS2))
      (instance ?REL AsymmetricRelation))

(=>
      (instance ?REL AntisymmetricRelation)
      (forall
            (?INST1 ?INST2)
            (=>
                  (and
                        (holds ?REL ?INST1 ?INST2)
                        (holds ?REL ?INST2 ?INST1))
                  (equal ?INST1 ?INST2))))

If rel ¬O ¤T¨¤Ãö«Y ªº ¹ê¨Ò, then for all inst1,inst2 holds: rel(inst1,inst2) (¤£) ¦¨¥ßs or inst1 µ¥©ó inst2 or rel(inst2,inst1) (¤£) ¦¨¥ßs.
(=>
      (instance ?REL TrichotomizingRelation)
      (forall
            (?INST1 ?INST2)
            (or
                  (holds ?REL ?INST1 ?INST2)
                  (equal ?INST1 ?INST2)
                  (holds ?REL ?INST2 ?INST1))))

(=>
      (instance ?REL TransitiveRelation)
      (forall
            (?INST1 ?INST2 ?INST3)
            (=>
                  (and
                        (holds ?REL ?INST1 ?INST2)
                        (holds ?REL ?INST2 ?INST3))
                  (holds ?REL ?INST1 ?INST3))))

(=>
      (instance ?REL IntransitiveRelation)
      (forall
            (?INST1 ?INST2 ?INST3)
            (=>
                  (and
                        (holds ?REL ?INST1 ?INST2)
                        (holds ?REL ?INST2 ?INST3))
                  (not
                        (holds ?REL ?INST1 ?INST3)))))

If rel ¬O ¥þ§ÇÃö«Y ªº ¹ê¨Ò, then for all inst1,inst2 holds: rel(inst1,inst2) (¤£) ¦¨¥ßs or rel(inst2,inst1) (¤£) ¦¨¥ßs.
(=>
      (instance ?REL TotalOrderingRelation)
      (forall
            (?INST1 ?INST2)
            (or
                  (holds ?REL ?INST1 ?INST2)
                  (holds ?REL ?INST2 ?INST1))))

If process ¬O ¾úµ{ ªº ¹ê¨Ò, then there exists cause so that process ¬O cause ªº ¬I¨ÆªÌ.
(=>
      (instance ?PROCESS Process)
      (exists
            (?CAUSE)
            (agent ?PROCESS ?CAUSE)))

If formula1 (¤£¡^¼W¥[s) %2 ªº ¥i¯à©Ê and "formula2 ªº ©ÎµM²v" µ¥©ó number1 and formula1 ªº ¾÷²v ¬O formula2 ¦b formula2 ¬°¯uªº±¡ªp¤U , then number2 (¤£) ¤j©ó number1.
(=>
      (and
            (increasesLikelihood ?FORMULA1 ?FORMULA2)
            (equal
                  (ProbabilityFn ?FORMULA2)
                  ?NUMBER1)
            (conditionalProbability ?FORMULA1 ?FORMULA2 ?NUMBER2))
      (greaterThan ?NUMBER2 ?NUMBER1))

If formula1 (¤£¡^­°§Cs) %2 ªº ¥i¯à©Ê and "formula2 ªº ©ÎµM²v" µ¥©ó number1 and formula1 ªº ¾÷²v ¬O formula2 ¦b formula2 ¬°¯uªº±¡ªp¤U , then number2 ¤p©ó number1.
(=>
      (and
            (decreasesLikelihood ?FORMULA1 ?FORMULA2)
            (equal
                  (ProbabilityFn ?FORMULA2)
                  ?NUMBER1)
            (conditionalProbability ?FORMULA1 ?FORMULA2 ?NUMBER2))
      (lessThan ?NUMBER2 ?NUMBER1))

If formula1 ©M formula2 ªº ©ÎµM²v ¬O ¿W¥ßªº and "formula2 ªº ©ÎµM²v" µ¥©ó number1 and formula1 ªº ¾÷²v ¬O formula2 ¦b formula2 ¬°¯uªº±¡ªp¤U , then number2 µ¥©ó number1.
(=>
      (and
            (independentProbability ?FORMULA1 ?FORMULA2)
            (equal
                  (ProbabilityFn ?FORMULA2)
                  ?NUMBER1)
            (conditionalProbability ?FORMULA1 ?FORMULA2 ?NUMBER2))
      (equal ?NUMBER2 ?NUMBER1))

If formula1 ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò and formula2 ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò, then formula1 (¤£¡^¼W¥[s) %2 ªº ¥i¯à©Ê or formula1 (¤£¡^­°§Cs) %2 ªº ¥i¯à©Ê or formula1 ©M formula2 ªº ©ÎµM²v ¬O ¿W¥ßªº.
(=>
      (and
            (instance ?FORMULA1 Formula)
            (instance ?FORMULA2 Formula))
      (or
            (increasesLikelihood ?FORMULA1 ?FORMULA2)
            (decreasesLikelihood ?FORMULA1 ?FORMULA2)
            (independentProbability ?FORMULA1 ?FORMULA2)))

If rel ¬O ·N¹ÏÃö«Y ªº ¹ê¨Ò and rel(agent,) (¤£) ¦¨¥ßs and obj ¬O "()" ªº ¤@ ¦¨­û, then agent ¦b obj ½d³ò¤¤.
(=>
      (and
            (instance ?REL IntentionalRelation)
            (holds ?REL ?AGENT @ROW)
            (inList
                  ?OBJ
                  (ListFn @ROW)))
      (inScopeOfInterest ?AGENT ?OBJ))

(=>
      (prefers ?AGENT ?FORMULA1 ?FORMULA2)
      (=>
            (true ?FORMULA1 True)
            (true ?FORMULA2 False)))

If agent (¤£) »Ý­nnot(s) object, then agent (¤£) ·Q­nnot(s) object.
(=>
      (needs ?AGENT ?OBJECT)
      (wants ?AGENT ?OBJECT))

If agent (¤£) ·Q­nnot(s) obj, then there exists purp so that obj ¹ïagent ¦³ ·N¹Ï purp.
(=>
      (wants ?AGENT ?OBJ)
      (exists
            (?PURP)
            (hasPurposeForAgent ?OBJ ?PURP ?AGENT)))

If agent (¤£) ·Q­nnot(s) obj, then agent (¤£) ¾¬¨Dnot(s) "agent (¨S) ¾Ö¦³not(s) obj".
(=>
      (wants ?AGENT ?OBJ)
      (desires
            ?AGENT
            (possesses ?AGENT ?OBJ)))

If agent (¤£)¬Û«H formula, then there exists time so that agent (¤£) ¦Ò¼{p{s} formula timea(¤§¤¤) time.
(=>
      (believes ?AGENT ?FORMULA)
      (exists
            (?TIME)
            (holdsDuring
                  ?TIME
                  (considers ?AGENT ?FORMULA))))

If agent (¤£¡^ª¾¹Ds) %2, then agent (¤£)¬Û«H formula.
(=>
      (knows ?AGENT ?FORMULA)
      (believes ?AGENT ?FORMULA))

If agent (¤£¡^ª¾¹Ds) %2, then formula &$¬O ¯uªº.
(=>
      (knows ?AGENT ?FORMULA)
      (true ?FORMULA True))

If rel ¬O ¤T¤¸Ãö«Y ªº ¹ê¨Ò, then there don't exist item1,item2,item3,item4, so that rel(item1,item2,item3,item4,) (¤£) ¦¨¥ßs.
(=>
      (instance ?REL TernaryRelation)
      (not
            (exists
                  (?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW)
                  (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 @ROW))))

If rel ¬O ¥|¤¸Ãö«Y ªº ¹ê¨Ò, then there don't exist item1,item2,item3,item4,item5, so that rel(item1,item2,item3,item4,item5,) (¤£) ¦¨¥ßs.
(=>
      (instance ?REL QuaternaryRelation)
      (not
            (exists
                  (?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW)
                  (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 @ROW))))

If rel ¬O ¤­¤¸Ãö«Y ªº ¹ê¨Ò, then there don't exist item1,item2,item3,item4,item5,item6, so that rel(item1,item2,item3,item4,item5,item6,) (¤£) ¦¨¥ßs.
(=>
      (instance ?REL QuintaryRelation)
      (not
            (exists
                  (?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW)
                  (holds ?REL ?ITEM1 ?ITEM2 ?ITEM3 ?ITEM4 ?ITEM5 ?ITEM6 @ROW))))

(=>
      (instance ?LIST List)
      (exists
            (?NUMBER1)
            (exists
                  (?ITEM1)
                  (and
                        (not
                              (equal
                                    (ListOrderFn ?LIST ?NUMBER1)
                                    ?ITEM1))
                        (forall
                              (?NUMBER2)
                              (=>
                                    (and
                                          (instance ?NUMBER2 PositiveInteger)
                                          (lessThan ?NUMBER2 ?NUMBER1))
                                    (exists
                                          (?ITEM2)
                                          (equal
                                                (ListOrderFn ?LIST ?NUMBER2)
                                                ?ITEM2))))))))

list ¬O °ß¤@§Ç¦C ªº ¹ê¨Ò if and only if for all number1,number2 holds: if "list ªº ²Ä¤G ¤¸¯À" µ¥©ó "list ªº ²Ä¤G ¤¸¯À", then number1 µ¥©ó number2.
(<=>
      (instance ?LIST UniqueList)
      (forall
            (?NUMBER1 ?NUMBER2)
            (=>
                  (equal
                        (ListOrderFn ?LIST ?NUMBER1)
                        (ListOrderFn ?LIST ?NUMBER2))
                  (equal ?NUMBER1 ?NUMBER2))))

(=>
      (exhaustiveDecomposition ?CLASS @ROW)
      (forall
            (?OBJ)
            (=>
                  (instance ?OBJ ?CLASS)
                  (exists
                        (?ITEM)
                        (and
                              (inList
                                    ?ITEM
                                    (ListFn @ROW))
                              (instance ?OBJ ?ITEM))))))

(=>
      (disjointDecomposition ?CLASS @ROW)
      (forall
            (?ITEM)
            (=>
                  (inList
                        ?ITEM
                        (ListFn @ROW))
                  (subclass ?ITEM ?CLASS))))

(=>
      (disjointDecomposition ?CLASS @ROW)
      (forall
            (?ITEM1 ?ITEM2)
            (=>
                  (and
                        (inList
                              ?ITEM1
                              (ListFn @ROW))
                        (inList
                              ?ITEM2
                              (ListFn @ROW))
                        (not
                              (equal ?ITEM1 ?ITEM2)))
                  (disjoint ?ITEM1 ?ITEM2))))

If list1 ¬O §Ç¦C ªº ¹ê¨Ò and list2 ¬O §Ç¦C ªº ¹ê¨Ò and for all number holds: "list1 ªº ²Ä¤G ¤¸¯À" µ¥©ó "list2 ªº ²Ä¤G ¤¸¯À", then list1 µ¥©ó list2.
(=>
      (and
            (instance ?LIST1 List)
            (instance ?LIST2 List)
            (forall
                  (?NUMBER)
                  (equal
                        (ListOrderFn ?LIST1 ?NUMBER)
                        (ListOrderFn ?LIST2 ?NUMBER))))
      (equal ?LIST1 ?LIST2))

If rel ªº ½×¤¸ number ¬O class ªº ¹ê¨Ò and rel() (¤£) ¦¨¥ßs, then ""()" ªº ²Ä¤G ¤¸¯À" ¬O class ªº ¹ê¨Ò.
(=>
      (and
            (domain ?REL ?NUMBER ?CLASS)
            (holds ?REL @ROW))
      (instance
            (ListOrderFn
                  (ListFn @ROW)
                  ?NUMBER)
            ?CLASS))

If rel ªº ½×¤¸ number ¬O class ªº ¦¸ºØÃþ and rel() (¤£) ¦¨¥ßs, then ""()" ªº ²Ä¤G ¤¸¯À" ¬O class ªº ¦¸ºØÃþ.
(=>
      (and
            (domainSubclass ?REL ?NUMBER ?CLASS)
            (holds ?REL @ROW))
      (subclass
            (ListOrderFn
                  (ListFn @ROW)
                  ?NUMBER)
            ?CLASS))

If "list ªº ªø«×" µ¥©ó number1, then for all number2 holds: there exists item so that "list ªº ²Ä¤G ¤¸¯À" µ¥©ó item if and only if number2 ¤p©ó©Îµ¥©ó number1.
(=>
      (equal
            (ListLengthFn ?LIST)
            ?NUMBER1)
      (forall
            (?NUMBER2)
            (<=>
                  (exists
                        (?ITEM)
                        (equal
                              (ListOrderFn ?LIST ?NUMBER2)
                              ?ITEM))
                  (lessThanOrEqualTo ?NUMBER2 ?NUMBER1))))

(=>
      (valence ?REL ?NUMBER)
      (forall
            (@ROW)
            (=>
                  (holds ?REL @ROW)
                  (equal
                        (ListLengthFn
                              (ListFn @ROW))
                        ?NUMBER))))

If "list1 ªº ªø«×" µ¥©ó number, then there exists list2 so that list1 (¨S¡^ªì©l¤Ænot(s) list2 and "(number+1)" µ¥©ó "list2 ªº ªø«×" and "list2 ªº ²Ä¤G ¤¸¯À" µ¥©ó item.
(=>
      (equal
            (ListLengthFn ?LIST1)
            ?NUMBER)
      (exists
            (?LIST2)
            (and
                  (initialList ?LIST1 ?LIST2)
                  (equal
                        (SuccessorFn ?NUMBER)
                        (ListLengthFn ?LIST2))
                  (equal
                        (ListOrderFn
                              ?LIST2
                              (SuccessorFn ?NUMBER))
                        ?ITEM))))

list3 µ¥©ó "list1 ©M list2 ²Õ¦¨ªº §Ç¦C" if and only if for all number1,number2 holds: if number1 ¤p©ó©Îµ¥©ó "list1 ªº ªø«×" and number2 ¤p©ó©Îµ¥©ó "list2 ªº ªø«×" and number1 ¬O ¥¿¾ã¼Æ ªº ¹ê¨Ò and number2 ¬O ¥¿¾ã¼Æ ªº ¹ê¨Ò, then "list3 ªº ²Ä¤G ¤¸¯À" µ¥©ó "list1 ªº ²Ä¤G ¤¸¯À" and "list3 ªº ²Ä¤G ¤¸¯À" µ¥©ó "list2 ªº ²Ä¤G ¤¸¯À".
(<=>
      (equal
            ?LIST3
            (ListConcatenateFn ?LIST1 ?LIST2))
      (forall
            (?NUMBER1 ?NUMBER2)
            (=>
                  (and
                        (lessThanOrEqualTo
                              ?NUMBER1
                              (ListLengthFn ?LIST1))
                        (lessThanOrEqualTo
                              ?NUMBER2
                              (ListLengthFn ?LIST2))
                        (instance ?NUMBER1 PositiveInteger)
                        (instance ?NUMBER2 PositiveInteger))
                  (and
                        (equal
                              (ListOrderFn ?LIST3 ?NUMBER1)
                              (ListOrderFn ?LIST1 ?NUMBER1))
                        (equal
                              (ListOrderFn
                                    ?LIST3
                                    (AdditionFn
                                          (ListLengthFn ?LIST1)
                                          ?NUMBER2))
                              (ListOrderFn ?LIST2 ?NUMBER2))))))

(=>
      (subList ?LIST1 ?LIST2)
      (forall
            (?ITEM)
            (=>
                  (inList ?ITEM ?LIST1)
                  (inList ?ITEM ?LIST2))))

(=>
      (subList ?LIST1 ?LIST2)
      (exists
            (?NUMBER3)
            (forall
                  (?ITEM)
                  (=>
                        (inList ?ITEM ?LIST1)
                        (exists
                              (?NUMBER1 ?NUMBER2)
                              (and
                                    (equal
                                          (ListOrderFn ?LIST1 ?NUMBER1)
                                          ?ITEM)
                                    (equal
                                          (ListOrderFn ?LIST2 ?NUMBER2)
                                          ?ITEM)
                                    (equal
                                          ?NUMBER2
                                          (AdditionFn ?NUMBER1 ?NUMBER3))))))))

(=>
      (initialList ?LIST1 ?LIST2)
      (forall
            (?NUMBER1 ?NUMBER2)
            (=>
                  (and
                        (equal
                              (ListLengthFn ?LIST1)
                              ?NUMBER1)
                        (lessThanOrEqualTo ?NUMBER2 ?NUMBER1))
                  (equal
                        (ListOrderFn ?LIST1 ?NUMBER2)
                        (ListOrderFn ?LIST2 ?NUMBER2)))))

If function ¬O ¤@¤¸¨ç¼Æ ªº ¹ê¨Ò, then function %&¦³ ½×¤¸(s) .
(=>
      (instance ?FUNCTION UnaryFunction)
      (valence ?FUNCTION 1))

(=>
      (instance ?FUN OneToOneFunction)
      (forall
            (?ARG1 ?ARG2)
            (=>
                  (and
                        (domain ?FUN 1 ?CLASS)
                        (instance ?ARG1 ?CLASS)
                        (instance ?ARG2 ?CLASS)
                        (not
                              (equal ?ARG1 ?ARG2)))
                  (not
                        (equal
                              (AssignmentFn ?FUN ?ARG1)
                              (AssignmentFn ?FUN ?ARG2))))))

If seq ¬O ¶¶§Ç¨ç¼Æ ªº ¹ê¨Ò and seq ªº ½d³ò ¬O class ªº ¹ê¨Ò, then class ¬O ¾ã¼Æ ªº ¦¸ºØÃþ.
(=>
      (and
            (instance ?SEQ SequenceFunction)
            (range ?SEQ ?CLASS))
      (subclass ?CLASS Integer))

If function ¬O ¤G¤¸¨ç¼Æ ªº ¹ê¨Ò, then function %&¦³ ½×¤¸(s) .
(=>
      (instance ?FUNCTION BinaryFunction)
      (valence ?FUNCTION 2))

(=>
      (instance ?FUNCTION AssociativeFunction)
      (forall
            (?INST1 ?INST2 ?INST3)
            (=>
                  (and
                        (domain ?FUNCTION 1 ?CLASS)
                        (instance ?INST1 ?CLASS)
                        (instance ?INST2 ?CLASS)
                        (instance ?INST3 ?CLASS))
                  (equal
                        (AssignmentFn
                              ?FUNCTION
                              ?INST1
                              (AssignmentFn ?FUNCTION ?INST2 ?INST3))
                        (AssignmentFn
                              ?FUNCTION
                              (AssignmentFn ?FUNCTION ?INST1 ?INST2)
                              ?INST3)))))

(=>
      (instance ?FUNCTION CommutativeFunction)
      (forall
            (?INST1 ?INST2)
            (=>
                  (and
                        (domain ?FUNCTION 1 ?CLASS)
                        (instance ?INST1 ?CLASS)
                        (instance ?INST2 ?CLASS))
                  (equal
                        (AssignmentFn ?FUNCTION ?INST1 ?INST2)
                        (AssignmentFn ?FUNCTION ?INST2 ?INST1)))))

If function ¬O ¤T¤¸¨ç¼Æ ªº ¹ê¨Ò, then function %&¦³ ½×¤¸(s) .
(=>
      (instance ?FUNCTION TernaryFunction)
      (valence ?FUNCTION 3))

If function ¬O ¥|¤¸¨ç¼Æ ªº ¹ê¨Ò, then function %&¦³ ½×¤¸(s) .
(=>
      (instance ?FUNCTION QuaternaryFunction)
      (valence ?FUNCTION 4))

If rel ¬O ¤G¤¸­zµü ªº ¹ê¨Ò, then rel %&¦³ ½×¤¸(s) .
(=>
      (instance ?REL BinaryPredicate)
      (valence ?REL 2))

If rel ¬O ¤T¤¸­zµü ªº ¹ê¨Ò, then rel %&¦³ ½×¤¸(s) .
(=>
      (instance ?REL TernaryPredicate)
      (valence ?REL 3))

If rel ¬O ¥|¤¸­zµü ªº ¹ê¨Ò, then rel %&¦³ ½×¤¸(s) .
(=>
      (instance ?REL QuaternaryPredicate)
      (valence ?REL 4))

If rel ¬O ¤­¤¸­zµü ªº ¹ê¨Ò, then rel %&¦³ ½×¤¸(s) .
(=>
      (instance ?REL QuintaryPredicate)
      (valence ?REL 5))

If rel ¬O Åܲ§¤¸¼ÆÃö«Y ªº ¹ê¨Ò, then there doesn't exist int so that rel %&¦³ ½×¤¸(s) int.
(=>
      (instance ?REL VariableArityRelation)
      (not
            (exists
                  (?INT)
                  (valence ?REL ?INT))))

(=>
      (and
            (closedOn ?FUNCTION ?CLASS)
            (instance ?FUNCTION UnaryFunction))
      (forall
            (?INST)
            (=>
                  (instance ?INST ?CLASS)
                  (instance
                        (AssignmentFn ?FUNCTION ?INST)
                        ?CLASS))))

(=>
      (and
            (closedOn ?FUNCTION ?CLASS)
            (instance ?FUNCTION BinaryFunction))
      (forall
            (?INST1 ?INST2)
            (=>
                  (and
                        (instance ?INST1 ?CLASS)
                        (instance ?INST2 ?CLASS))
                  (instance
                        (AssignmentFn ?FUNCTION ?INST1 ?INST2)
                        ?CLASS))))

(=>
      (reflexiveOn ?RELATION ?CLASS)
      (forall
            (?INST)
            (=>
                  (instance ?INST ?CLASS)
                  (holds ?RELATION ?INST ?INST))))

(=>
      (irreflexiveOn ?RELATION ?CLASS)
      (forall
            (?INST)
            (=>
                  (instance ?INST ?CLASS)
                  (not
                        (holds ?RELATION ?INST ?INST)))))

If relation °¾§Ç©ó class, then relation ¤ÏÀ³©ó class and relation ¬O ¥i»¼Ãö«Y ªº ¹ê¨Ò and relation ¬O ¤Ï¹ïºÙÃö«Y ªº ¹ê¨Ò.
(=>
      (partialOrderingOn ?RELATION ?CLASS)
      (and
            (reflexiveOn ?RELATION ?CLASS)
            (instance ?RELATION TransitiveRelation)
            (instance ?RELATION AntisymmetricRelation)))

(=>
      (trichotomizingOn ?RELATION ?CLASS)
      (forall
            (?INST1 ?INST2)
            (=>
                  (and
                        (instance ?INST1 ?CLASS)
                        (instance ?INST2 ?CLASS))
                  (or
                        (holds ?RELATION ?INST1 ?INST2)
                        (holds ?RELATION ?INST2 ?INST1)
                        (equal ?INST1 ?INST2)))))

If relation µ¥¦PÃö«Y ©ó class , then relation ¬O ¥i»¼Ãö«Y ªº ¹ê¨Ò and relation ¬O ¹ïºÙÃö«Y ªº ¹ê¨Ò and relation ¤ÏÀ³©ó class .
(=>
      (equivalenceRelationOn ?RELATION ?CLASS)
      (and
            (instance ?RELATION TransitiveRelation)
            (instance ?RELATION SymmetricRelation)
            (reflexiveOn ?RELATION ?CLASS)))

(=>
      (distributes ?FUNCTION1 ?FUNCTION2)
      (forall
            (?INST1 ?INST2 ?INST3)
            (=>
                  (and
                        (domain ?FUNCTION1 1 ?CLASS1)
                        (instance ?INST1 ?CLASS1)
                        (instance ?INST2 ?CLASS1)
                        (instance ?INST3 ?CLASS1)
                        (domain ?FUNCTION2 1 ?CLASS2)
                        (instance ?INST1 ?CLASS2)
                        (instance ?INST2 ?CLASS2)
                        (instance ?INST3 ?CLASS2))
                  (equal
                        (AssignmentFn
                              ?FUNCTION1
                              ?INST1
                              (AssignmentFn ?FUNCTION2 ?INST2 ?INST3))
                        (AssignmentFn
                              ?FUNCTION2
                              (AssignmentFn ?FUNCTION1 ?INST1 ?INST2)
                              (AssignmentFn ?FUNCTION1 ?INST1 ?INST3))))))

If proc1 ¬O ¾úµ{ ªº ¹ê¨Ò, then there exists proc2 so that proc2 (¤£) ³y¦¨ proc1.
(=>
      (instance ?PROC1 Process)
      (exists
            (?PROC2)
            (causes ?PROC2 ?PROC1)))

(=>
      (causesSubclass ?PROC1 ?PROC2)
      (forall
            (?INST2)
            (=>
                  (instance ?INST2 ?PROC2)
                  (exists
                        (?INST1)
                        (and
                              (instance ?INST1 ?PROC1)
                              (causes ?INST1 ?INST2))))))

(=>
      (copy ?OBJ1 ?OBJ2)
      (forall
            (?ATTR)
            (=>
                  (attribute ?OBJ1 ?ATTR)
                  (attribute ?OBJ2 ?ATTR))))

If situation1 (¨S) ¬°¯u timea(¤§¤¤) time and ±Àª¾(situation1,situation2) holds, then situation2 (¨S) ¬°¯u timea(¤§¤¤) time.
(=>
      (and
            (holdsDuring ?TIME ?SITUATION1)
            (entails ?SITUATION1 ?SITUATION2))
      (holdsDuring ?TIME ?SITUATION2))

If situation timea(¤§¤¤) time, then situation (¨S) ¬°¯u timea(¤§¤¤) time.
(=>
      (holdsDuring
            ?TIME
            (not ?SITUATION))
      (not
            (holdsDuring ?TIME ?SITUATION)))

If role ¬O ®æ¦ì¨¤¦â ªº ¹ê¨Ò and role(arg1,arg2) (¤£) ¦¨¥ßs and arg1 ¬O proc ªº ¹ê¨Ò, then arg2 ¥i¥H ¥ô¨¤¦â role °µ proc.
(=>
      (and
            (instance ?ROLE CaseRole)
            (holds ?ROLE ?ARG1 ?ARG2)
            (instance ?ARG1 ?PROC))
      (capability ?PROC ?ROLE ?ARG2))

If obj (¤£) §Q¥Înot(s) agent, then there exists process so that process ¬O agent ªº ¬I¨ÆªÌ and obj ¹ï process ¬O ¸ê·½.
(=>
      (exploits ?OBJ ?AGENT)
      (exists
            (?PROCESS)
            (and
                  (agent ?PROCESS ?AGENT)
                  (resource ?PROCESS ?OBJ))))

If thing ¦³ ·N¹Ï purpose, then there exists agent so that thing ¹ïagent ¦³ ·N¹Ï purpose.
(=>
      (hasPurpose ?THING ?PURPOSE)
      (exists
            (?AGENT)
            (hasPurposeForAgent ?THING ?PURPOSE ?AGENT)))

If ¦³§Þ¥©(proc,agent) holds, then agent ¥i¥H ¥ô¨¤¦â ¬I¨ÆªÌ °µ proc.
(=>
      (hasSkill ?PROC ?AGENT)
      (capability ?PROC agent ?AGENT))

If agent ¦³ Åv ¨Ï process ¬°¯u, then agent ¥i¥H ¥ô¨¤¦â ¬I¨ÆªÌ °µ process.
(=>
      (holdsRight ?PROCESS ?AGENT)
      (capability ?PROCESS agent ?AGENT))

If agent1 ½á¤© agent2 Åv¤O °õ¦æ Ãþ«¬ process ¥ô°È, then agent2 ¦³ Åv ¨Ï process ¬°¯u.
(=>
      (confersRight ?PROCESS ?AGENT1 ?AGENT2)
      (holdsRight ?PROCESS ?AGENT2))

If agent ¦³¸q°È °õ¦æ Ãþ«¬ process ¥ô°È, then agent ¥i¥H ¥ô¨¤¦â ¬I¨ÆªÌ °µ process.
(=>
      (holdsObligation ?PROCESS ?AGENT)
      (capability ?PROCESS agent ?AGENT))

If agent1 ½á¤© agent2 ¸q°È °õ¦æ Ãþ«¬ process ¥ô°È, then agent2 ¦³¸q°È °õ¦æ Ãþ«¬ process ¥ô°È.
(=>
      (confersObligation ?PROCESS ?AGENT1 ?AGENT2)
      (holdsObligation ?PROCESS ?AGENT2))

(=>
      (located ?OBJ ?REGION)
      (forall
            (?SUBOBJ)
            (=>
                  (part ?SUBOBJ ?OBJ)
                  (located ?SUBOBJ ?REGION))))

If obj ³¡¤À¦ì©ó region, then there exists subobj so that subobj ¬O obj ªº ³¡¤À) and subobj ºë½T¦ì©ó region.
(=>
      (partlyLocated ?OBJ ?REGION)
      (exists
            (?SUBOBJ)
            (and
                  (part ?SUBOBJ ?OBJ)
                  (exactlyLocated ?SUBOBJ ?REGION))))

If obj ºë½T¦ì©ó region, then there doesn't exist otherobj so that otherobj ºë½T¦ì©ó region and otherobj µ¥©ó obj.
(=>
      (exactlyLocated ?OBJ ?REGION)
      (not
            (exists
                  (?OTHEROBJ)
                  (and
                        (exactlyLocated ?OTHEROBJ ?REGION)
                        (not
                              (equal ?OTHEROBJ ?OBJ))))))

If obj1 ¾î¶V obj2, then obj1 »P obj2 ¬Û¥æ or ¬ï¤J(obj1,obj2) holds.
(=>
      (traverses ?OBJ1 ?OBJ2)
      (or
            (crosses ?OBJ1 ?OBJ2)
            (penetrates ?OBJ1 ?OBJ2)))

(=>
      (possesses ?PERSON ?OBJ)
      (exists
            (?TYPE)
            (and
                  (holdsRight ?PERSON ?TYPE)
                  (forall
                        (?PROCESS)
                        (=>
                              (instance ?PROCESS ?TYPE)
                              (patient ?PROCESS ?OBJ))))))

If time ¬O ®É¶¡ ªº ¹ê¨Ò and agent1 (¨S) ¾Ö¦³not(s) obj timea(¤§¤¤) time and agent2 (¨S) ¾Ö¦³not(s) obj timea(¤§¤¤) time, then agent1 µ¥©ó agent2.
(=>
      (and
            (instance ?TIME TimePosition)
            (holdsDuring
                  ?TIME
                  (possesses ?AGENT1 ?OBJ))
            (holdsDuring
                  ?TIME
                  (possesses ?AGENT2 ?OBJ)))
      (equal ?AGENT1 ?AGENT2))

(=>
      (precondition ?PROC1 ?PROC2)
      (=>
            (exists
                  (?INST2)
                  (instance ?INST2 ?PROC2))
            (exists
                  (?INST1)
                  (instance ?INST1 ?PROC1))))

If §í¨î(proc1,proc2) holds, then for all time,place holds: "there exists proc1 inst1 so that inst1 ¦ì©ó place timea(¤§¤¤) time" (¤£¡^­°§Cs) %2 ªº ¥i¯à©Ê.
(=>
      (inhibits ?PROC1 ?PROC2)
      (forall
            (?TIME ?PLACE)
            (decreasesLikelihood
                  (holdsDuring
                        ?TIME
                        (exists
                              (?INST1)
                              (and
                                    (instance ?INST1 ?PROC1)
                                    (located ?INST1 ?PLACE))))
                  (holdsDuring
                        ?TIME
                        (exists
                              (?INST2)
                              (and
                                    (instance ?INST2 ?PROC2)
                                    (located ?INST2 ?PLACE)))))))

(=>
      (prevents ?PROC1 ?PROC2)
      (forall
            (?TIME ?PLACE)
            (=>
                  (holdsDuring
                        ?TIME
                        (exists
                              (?INST1)
                              (and
                                    (instance ?INST1 ?PROC1)
                                    (located ?INST1 ?PLACE))))
                  (not
                        (holdsDuring
                              ?TIME
                              (exists
                                    (?INST2)
                                    (and
                                          (instance ?INST2 ?PROC2)
                                          (located ?INST2 ?PLACE))))))))

If agent ¨Ï¥Î rep ªí¥Ü entity, then rep ªí¹F entity.
(=>
      (representsForAgent ?REP ?ENTITY ?AGENT)
      (represents ?REP ?ENTITY))

If rep ¥H»y¨¥ language §e²{ entity, then there exists agent so that agent ¨Ï¥Î rep ªí¥Ü entity.
(=>
      (representsInLanguage ?REP ?ENTITY ?LANGUAGE)
      (exists
            (?AGENT)
            (representsForAgent ?REP ?ENTITY ?AGENT)))

class1 ¥]®e class2 if and only if for all obj2,info holds: if obj2 ¬O class2 ªº ¹ê¨Ò and obj2 (¤£) ¥]§ts) °T®§ %2, then there exists class1 obj1 so that obj1 (¤£) ¥]§ts) °T®§ %2.
(<=>
      (subsumesContentClass ?CLASS1 ?CLASS2)
      (forall
            (?OBJ2 ?INFO)
            (=>
                  (and
                        (instance ?OBJ2 ?CLASS2)
                        (containsInformation ?OBJ2 ?INFO))
                  (exists
                        (?OBJ1)
                        (and
                              (instance ?OBJ1 ?CLASS1)
                              (containsInformation ?OBJ1 ?INFO))))))

obj1 ¥]®e obj2 if and only if for all info holds: if obj2 (¤£) ¥]§ts) °T®§ %2, then obj1 (¤£) ¥]§ts) °T®§ %2.
(<=>
      (subsumesContentInstance ?OBJ1 ?OBJ2)
      (forall
            (?INFO)
            (=>
                  (containsInformation ?OBJ2 ?INFO)
                  (containsInformation ?OBJ1 ?INFO))))

If process ªí¹F prop ªº ¤º®e, then there exists ¤º®e¸üÅé obj so that obj (¤£) ¥]§ts) °T®§ %2.
(=>
      (realization ?PROCESS ?PROP)
      (exists
            (?OBJ)
            (and
                  (instance ?OBJ ContentBearingObject)
                  (containsInformation ?OBJ ?PROP))))

(=>
      (subProposition ?PROP1 ?PROP2)
      (forall
            (?OBJ1 ?OBJ2)
            (=>
                  (and
                        (containsInformation ?OBJ1 ?PROP1)
                        (containsInformation ?OBJ2 ?PROP2))
                  (subsumesContentInstance ?OBJ2 ?OBJ1))))

If agent ¨Ï¥Î obj, then there exists proc so that proc ¬O agent ªº ¬I¨ÆªÌ and obj ¹ï proc ¬O ¤u¨ã.
(=>
      (uses ?OBJ ?AGENT)
      (exists
            (?PROC)
            (and
                  (agent ?PROC ?AGENT)
                  (instrument ?PROC ?OBJ))))

If number ¬O ¦³²z¼Æ ªº ¹ê¨Ò, then there exist ¾ã¼Æ int1,¾ã¼Æ int2 so that number µ¥©ó "int1/int2".
(=>
      (instance ?NUMBER RationalNumber)
      (exists
            (?INT1 ?INT2)
            (and
                  (instance ?INT1 Integer)
                  (instance ?INT2 Integer)
                  (equal
                        ?NUMBER
                        (DivisionFn ?INT1 ?INT2)))))

If "number ªº ¤W­­" µ¥©ó int, then there doesn't exist ¾ã¼Æ otherint so that otherint ¤j©ó©Îµ¥©ó number and otherint ¤p©ó int.
(=>
      (equal
            (CeilingFn ?NUMBER)
            ?INT)
      (not
            (exists
                  (?OTHERINT)
                  (and
                        (instance ?OTHERINT Integer)
                        (greaterThanOrEqualTo ?OTHERINT ?NUMBER)
                        (lessThan ?OTHERINT ?INT)))))

If "³Ì¤j ¾ã¼Æ ¤p©ó ©Î µ¥©ó number" µ¥©ó int, then there doesn't exist ¾ã¼Æ otherint so that otherint ¤p©ó©Îµ¥©ó number and otherint (¤£) ¤j©ó int.
(=>
      (equal
            (FloorFn ?NUMBER)
            ?INT)
      (not
            (exists
                  (?OTHERINT)
                  (and
                        (instance ?OTHERINT Integer)
                        (lessThanOrEqualTo ?OTHERINT ?NUMBER)
                        (greaterThan ?OTHERINT ?INT)))))

(=>
      (equal
            (GreatestCommonDivisorFn @ROW)
            ?NUMBER)
      (forall
            (?ELEMENT)
            (=>
                  (inList
                        ?ELEMENT
                        (ListFn @ROW))
                  (equal
                        (RemainderFn ?ELEMENT ?NUMBER)
                        0))))

(=>
      (equal
            (GreatestCommonDivisorFn @ROW)
            ?NUMBER)
      (not
            (exists
                  (?GREATER)
                  (and
                        (greaterThan ?GREATER ?NUMBER)
                        (forall
                              (?ELEMENT)
                              (=>
                                    (inList
                                          ?ELEMENT
                                          (ListFn @ROW))
                                    (equal
                                          (RemainderFn ?ELEMENT ?GREATER)
                                          0)))))))

If number ¬O ½Æ¼Æ ªº ¹ê¨Ò, then there exist part1,part2 so that part1 µ¥©ó "number ªº ¹ê¼Æ" and part2 µ¥©ó "number ªº µê¼Æ".
(=>
      (instance ?NUMBER ComplexNumber)
      (exists
            (?PART1 ?PART2)
            (and
                  (equal
                        ?PART1
                        (RealNumberFn ?NUMBER))
                  (equal
                        ?PART2
                        (ImaginaryPartFn ?NUMBER)))))

(=>
      (equal
            (LeastCommonMultipleFn @ROW)
            ?NUMBER)
      (forall
            (?ELEMENT)
            (=>
                  (inList
                        ?ELEMENT
                        (ListFn @ROW))
                  (equal
                        (RemainderFn ?NUMBER ?ELEMENT)
                        0))))

(=>
      (equal
            (LeastCommonMultipleFn @ROW)
            ?NUMBER)
      (not
            (exists
                  (?LESS)
                  (and
                        (lessThan ?LESS ?NUMBER)
                        (forall
                              (?ELEMENT)
                              (=>
                                    (inList
                                          ?ELEMENT
                                          (ListFn @ROW))
                                    (equal
                                          (RemainderFn ?LESS ?ELEMENT)
                                          0)))))))

If "number1 ©M number2 ªº ³Ì¤j­È " µ¥©ó number, then
(=>
      (equal
            (MaxFn ?NUMBER1 ?NUMBER2)
            ?NUMBER)
      (or
            (and
                  (equal ?NUMBER ?NUMBER1)
                  (greaterThan ?NUMBER1 ?NUMBER2))
            (and
                  (equal ?NUMBER ?NUMBER2)
                  (greaterThan ?NUMBER2 ?NUMBER1))
            (and
                  (equal ?NUMBER ?NUMBER1)
                  (equal ?NUMBER ?NUMBER2))))

If "number1 ©M number2 ªº ³Ì¤p­È " µ¥©ó number, then
(=>
      (equal
            (MinFn ?NUMBER1 ?NUMBER2)
            ?NUMBER)
      (or
            (and
                  (equal ?NUMBER ?NUMBER1)
                  (lessThan ?NUMBER1 ?NUMBER2))
            (and
                  (equal ?NUMBER ?NUMBER2)
                  (lessThan ?NUMBER2 ?NUMBER1))
            (and
                  (equal ?NUMBER ?NUMBER1)
                  (equal ?NUMBER ?NUMBER2))))

If number ¬O ¼Æ¶q ªº ¹ê¨Ò, then "number ªº ­Ë¼Æ" µ¥©ó "number ­¼¥H ¦¸¤è".
(=>
      (instance ?NUMBER Quantity)
      (equal
            (ReciprocalFn ?NUMBER)
            (ExponentiationFn ?NUMBER -1)))

If number ¬O ¼Æ¶q ªº ¹ê¨Ò, then µ¥©ó "number*"number ªº ­Ë¼Æ"".
(=>
      (instance ?NUMBER Quantity)
      (equal
            1
            (MultiplicationFn
                  ?NUMBER
                  (ReciprocalFn ?NUMBER))))

If "number1 ¨ú¾l¼Æ number2" µ¥©ó number, then "number2 ªº ¥¿­t¸¹" µ¥©ó "number ªº ¥¿­t¸¹".
(=>
      (equal
            (RemainderFn ?NUMBER1 ?NUMBER2)
            ?NUMBER)
      (equal
            (SignumFn ?NUMBER2)
            (SignumFn ?NUMBER)))

If number ¬O °¸¾ã¼Æ ªº ¹ê¨Ò, then "number ¨ú¾l¼Æ " µ¥©ó .
(=>
      (instance ?NUMBER EvenInteger)
      (equal
            (RemainderFn ?NUMBER 2)
            0))

If number ¬O ©_¾ã¼Æ ªº ¹ê¨Ò, then "number ¨ú¾l¼Æ " µ¥©ó .
(=>
      (instance ?NUMBER OddInteger)
      (equal
            (RemainderFn ?NUMBER 2)
            1))

(=>
      (instance ?PRIME PrimeNumber)
      (forall
            (?NUMBER)
            (=>
                  (equal
                        (RemainderFn ?PRIME ?NUMBER)
                        0)
                  (or
                        (equal ?NUMBER 1)
                        (equal ?NUMBER ?PRIME)))))

(=>
      (equal
            (RoundFn ?NUMBER1)
            ?NUMBER2)
      (or
            (=>
                  (lessThan
                        (SubtractionFn
                              ?NUMBER1
                              (FloorFn ?NUMBER1))
                        0.5)
                  (equal
                        ?NUMBER2
                        (FloorFn ?NUMBER1)))
            (=>
                  (greaterThanOrEqualTo
                        (SubtractionFn
                              ?NUMBER1
                              (FloorFn ?NUMBER1))
                        0.5)
                  (equal
                        ?NUMBER2
                        (CeilingFn ?NUMBER1)))))

If number ¬O «D­t¹ê¼Æ ªº ¹ê¨Ò, then "number ªº ¥¿­t¸¹" µ¥©ó or "number ªº ¥¿­t¸¹" µ¥©ó .
(=>
      (instance ?NUMBER NonnegativeRealNumber)
      (or
            (equal
                  (SignumFn ?NUMBER)
                  1)
            (equal
                  (SignumFn ?NUMBER)
                  0)))

If number ¬O ¥¿¹ê¼Æ ªº ¹ê¨Ò, then "number ªº ¥¿­t¸¹" µ¥©ó .
(=>
      (instance ?NUMBER PositiveRealNumber)
      (equal
            (SignumFn ?NUMBER)
            1))

If number ¬O ­t¹ê¼Æ ªº ¹ê¨Ò, then "number ªº ¥¿­t¸¹" µ¥©ó .
(=>
      (instance ?NUMBER NegativeRealNumber)
      (equal
            (SignumFn ?NUMBER)
            -1))

If "number1 ªº ¥­¤è®Ú" µ¥©ó number2, then "number2*number2" µ¥©ó number1.
(=>
      (equal
            (SquareRootFn ?NUMBER1)
            ?NUMBER2)
      (equal
            (MultiplicationFn ?NUMBER2 ?NUMBER2)
            ?NUMBER1))

If degree ¬O ¥­­±¨¤³æ¦ì ªº ¹ê¨Ò, then "degree ªº ¥¿¤Á" µ¥©ó ""degree ªº ¥¿©¶"/"degree ªº ¾l©¶"".
(=>
      (instance ?DEGREE PlaneAngleMeasure)
      (equal
            (TangentFn ?DEGREE)
            (DivisionFn
                  (SineFn ?DEGREE)
                  (CosineFn ?DEGREE))))

(=>
      (identityElement ?FUNCTION ?ID)
      (forall
            (?INST)
            (=>
                  (and
                        (domain ?FUNCTION 1 ?CLASS)
                        (instance ?INST ?CLASS))
                  (equal
                        (AssignmentFn ?FUNCTION ?ID ?INST)
                        ?INST))))

If "(int1+1)" µ¥©ó "(int2+1)", then int1 µ¥©ó int2.
(=>
      (equal
            (SuccessorFn ?INT1)
            (SuccessorFn ?INT2))
      (equal ?INT1 ?INT2))

If int ¬O ¾ã¼Æ ªº ¹ê¨Ò, then int ¤p©ó "(int+1)".
(=>
      (instance ?INT Integer)
      (lessThan
            ?INT
            (SuccessorFn ?INT)))

If int1 ¬O ¾ã¼Æ ªº ¹ê¨Ò and int2 ¬O ¾ã¼Æ ªº ¹ê¨Ò, then int1 ¤p©ó int2 or int2 ¤p©ó "(int1+1)".
(=>
      (and
            (instance ?INT1 Integer)
            (instance ?INT2 Integer))
      (not
            (and
                  (lessThan ?INT1 ?INT2)
                  (lessThan
                        ?INT2
                        (SuccessorFn ?INT1)))))

If int ¬O ¾ã¼Æ ªº ¹ê¨Ò, then int µ¥©ó "("(int+2)"+1)".
(=>
      (instance ?INT Integer)
      (equal
            ?INT
            (SuccessorFn
                  (PredecessorFn ?INT))))

If int ¬O ¾ã¼Æ ªº ¹ê¨Ò, then int µ¥©ó "("(int+1)"+2)".
(=>
      (instance ?INT Integer)
      (equal
            ?INT
            (PredecessorFn
                  (SuccessorFn ?INT))))

If "(int1+2)" µ¥©ó "(int2+2)", then int1 µ¥©ó int2.
(=>
      (equal
            (PredecessorFn ?INT1)
            (PredecessorFn ?INT2))
      (equal ?INT1 ?INT2))

If int ¬O ¾ã¼Æ ªº ¹ê¨Ò, then int (¤£) ¤j©ó "(int+2)".
(=>
      (instance ?INT Integer)
      (greaterThan
            ?INT
            (PredecessorFn ?INT)))

If int1 ¬O ¾ã¼Æ ªº ¹ê¨Ò and int2 ¬O ¾ã¼Æ ªº ¹ê¨Ò, then int2 ¤p©ó int1 or "(int1+2)" ¤p©ó int2.
(=>
      (and
            (instance ?INT1 Integer)
            (instance ?INT2 Integer))
      (not
            (and
                  (lessThan ?INT2 ?INT1)
                  (lessThan
                        (PredecessorFn ?INT1)
                        ?INT2))))

(=>
      (subset ?SUBSET ?SET)
      (forall
            (?ELEMENT)
            (=>
                  (element ?ELEMENT ?SUBSET)
                  (element ?ELEMENT ?SET))))

If for all element holds: element ¬O set1 ªº ¤¸¯À if and only if element ¬O set2 ªº ¤¸¯À, then set1 µ¥©ó set2.
(=>
      (forall
            (?ELEMENT)
            (<=>
                  (element ?ELEMENT ?SET1)
                  (element ?ELEMENT ?SET2)))
      (equal ?SET1 ?SET2))

If set ¬O ¦³­­¶°¦X ªº ¹ê¨Ò, then there exists «D­t¾ã¼Æ number so that number µ¥©ó "set ¤¤ ¹ê¨Ò ªº ¼Æ¥Ø".
(=>
      (instance ?SET FiniteSet)
      (exists
            (?NUMBER)
            (and
                  (instance ?NUMBER NonnegativeInteger)
                  (equal
                        ?NUMBER
                        (CardinalityFn ?SET)))))

(=>
      (instance ?SUPERCLASS PairwiseDisjointClass)
      (forall
            (?CLASS1 ?CLASS2)
            (=>
                  (and
                        (instance ?CLASS1 ?SUPERCLASS)
                        (instance ?CLASS2 ?SUPERCLASS))
                  (or
                        (equal ?CLASS1 ?CLASS2)
                        (disjoint ?CLASS1 ?CLASS2)))))

(=>
      (instance ?CLASS MutuallyDisjointClass)
      (forall
            (?INST1 ?INST2)
            (=>
                  (and
                        (instance ?INST1 ?CLASS)
                        (instance ?INST2 ?INST1))
                  (exists
                        (?INST3)
                        (and
                              (instance ?INST3 ?CLASS)
                              (not
                                    (instance ?INST2 ?INST3)))))))

If graph ¬O ¹Ï ªº ¹ê¨Ò and node1 ¬O ¹Ï¸`ÂI ªº ¹ê¨Ò and node2 ¬O ¹Ï¸`ÂI ªº ¹ê¨Ò and node1 ¬O graph ªº ³¡¤À and node2 ¬O graph ªº ³¡¤À and node1 µ¥©ó node2, then there exist arc,path so that
(=>
      (and
            (instance ?GRAPH Graph)
            (instance ?NODE1 GraphNode)
            (instance ?NODE2 GraphNode)
            (graphPart ?NODE1 ?GRAPH)
            (graphPart ?NODE2 ?GRAPH)
            (not
                  (equal ?NODE1 ?NODE2)))
      (exists
            (?ARC ?PATH)
            (or
                  (links ?NODE1 ?NODE2 ?ARC)
                  (and
                        (subGraph ?PATH ?GRAPH)
                        (instance ?PATH GraphPath)
                        (or
                              (and
                                    (equal
                                          (BeginNodeFn ?PATH)
                                          ?NODE1)
                                    (equal
                                          (EndNodeFn ?PATH)
                                          ?NODE2))
                              (and
                                    (equal
                                          (BeginNodeFn ?PATH)
                                          ?NODE2)
                                    (equal
                                          (EndNodeFn ?PATH)
                                          ?NODE1)))))))

If graph ¬O ¹Ï ªº ¹ê¨Ò, then there exist node1,node2,node3,arc1,arc2 so that node1 ¬O graph ªº ³¡¤À and node2 ¬O graph ªº ³¡¤À and node3 ¬O graph ªº ³¡¤À and arc1 ¬O graph ªº ³¡¤À and arc2 ¬O graph ªº ³¡¤À and node2 (¨S) ³sµ²not(s) arc1 ©M node1 and node3 (¨S) ³sµ²not(s) arc2 ©M node2 and node1 µ¥©ó node2 and node2 µ¥©ó node3 and node1 µ¥©ó node3 and arc1 µ¥©ó arc2.
(=>
      (instance ?GRAPH Graph)
      (exists
            (?NODE1 ?NODE2 ?NODE3 ?ARC1 ?ARC2)
            (and
                  (graphPart ?NODE1 ?GRAPH)
                  (graphPart ?NODE2 ?GRAPH)
                  (graphPart ?NODE3 ?GRAPH)
                  (graphPart ?ARC1 ?GRAPH)
                  (graphPart ?ARC2 ?GRAPH)
                  (links ?ARC1 ?NODE1 ?NODE2)
                  (links ?ARC2 ?NODE2 ?NODE3)
                  (not
                        (equal ?NODE1 ?NODE2))
                  (not
                        (equal ?NODE2 ?NODE3))
                  (not
                        (equal ?NODE1 ?NODE3))
                  (not
                        (equal ?ARC1 ?ARC2)))))

If graph ¬O ¦³¦V¹Ï ªº ¹ê¨Ò and arc ¬O ¹Ï©·½u ªº ¹ê¨Ò and arc ¬O graph ªº ³¡¤À, then there exist node1,node2 so that "arc ªº °_©l¸`ÂI" µ¥©ó node1 and "arc ªº ³Ì²×¸`ÂI" µ¥©ó node2.
(=>
      (and
            (instance ?GRAPH DirectedGraph)
            (instance ?ARC GraphArc)
            (graphPart ?ARC ?GRAPH))
      (exists
            (?NODE1 ?NODE2)
            (and
                  (equal
                        (InitialNodeFn ?ARC)
                        ?NODE1)
                  (equal
                        (TerminalNodeFn ?ARC)
                        ?NODE2))))

If graph ¬O ¾ðª¬¹Ï ªº ¹ê¨Ò, then there doesn't exist ¹Ï°j°é loop so that loop ¬O graph ªº ³¡¤À.
(=>
      (instance ?GRAPH Tree)
      (not
            (exists
                  (?LOOP)
                  (and
                        (instance ?LOOP GraphLoop)
                        (graphPart ?LOOP ?GRAPH)))))

(=>
      (and
            (instance ?GRAPH GraphPath)
            (instance ?ARC GraphArc)
            (graphPart ?ARC ?GRAPH))
      (=>
            (equal
                  (InitialNodeFn ?ARC)
                  ?NODE)
            (not
                  (exists
                        (?OTHER)
                        (and
                              (equal
                                    (InitialNodeFn ?OTHER)
                                    ?NODE)
                              (not
                                    (equal ?OTHER ?ARC)))))))

(=>
      (and
            (instance ?GRAPH GraphPath)
            (instance ?ARC GraphArc)
            (graphPart ?ARC ?GRAPH))
      (=>
            (equal
                  (TerminalNodeFn ?ARC)
                  ?NODE)
            (not
                  (exists
                        (?OTHER)
                        (and
                              (equal
                                    (TerminalNodeFn ?OTHER)
                                    ?NODE)
                              (not
                                    (equal ?OTHER ?ARC)))))))

If part ¬O ¹Ï¤¸¥ó ªº ¹ê¨Ò, then there exists ¹Ï graph so that part ¬O graph ªº ³¡¤À.
(=>
      (instance ?PART GraphElement)
      (exists
            (?GRAPH)
            (and
                  (instance ?GRAPH Graph)
                  (graphPart ?PART ?GRAPH))))

If node ¬O ¹Ï¸`ÂI ªº ¹ê¨Ò, then there exist other,arc so that arc (¨S) ³sµ²not(s) node ©M other.
(=>
      (instance ?NODE GraphNode)
      (exists
            (?OTHER ?ARC)
            (links ?NODE ?OTHER ?ARC)))

If arc ¬O ¹Ï©·½u ªº ¹ê¨Ò, then there exist node1,node2 so that arc (¨S) ³sµ²not(s) node1 ©M node2.
(=>
      (instance ?ARC GraphArc)
      (exists
            (?NODE1 ?NODE2)
            (links ?NODE1 ?NODE2 ?ARC)))

If "arc ªº °_©l¸`ÂI" µ¥©ó node and "arc ªº ³Ì²×¸`ÂI" µ¥©ó node, then arc ¬O ¹Ï°j°é ªº ¹ê¨Ò.
(=>
      (and
            (equal
                  (InitialNodeFn ?ARC)
                  ?NODE)
            (equal
                  (TerminalNodeFn ?ARC)
                  ?NODE))
      (instance ?ARC GraphLoop))

If arc (¨S) ³sµ²not(s) node1 ©M node2, then arc (¨S) ³sµ²not(s) node2 ©M node1.
(=>
      (links ?NODE1 ?NODE2 ?ARC)
      (links ?NODE2 ?NODE1 ?ARC))

If graph1 ¬O graph2 ªº ¦¸¹Ï and element ¬O graph1 ªº ³¡¤À, then element ¬O graph2 ªº ³¡¤À.
(=>
      (and
            (subGraph ?GRAPH1 ?GRAPH2)
            (graphPart ?ELEMENT ?GRAPH1))
      (graphPart ?ELEMENT ?GRAPH2))

(=>
      (and
            (equal
                  (PathWeightFn ?PATH)
                  ?SUM)
            (subGraph ?SUBPATH ?PATH)
            (graphPart ?ARC1 ?PATH)
            (arcWeight ?ARC1 ?NUMBER1)
            (forall
                  (?ARC2)
                  (=>
                        (graphPart ?ARC2 ?PATH)
                        (or
                              (graphPart ?ARC2 ?SUBPATH)
                              (equal ?ARC2 ?ARC1)))))
      (equal
            ?SUM
            (AdditionFn
                  (PathWeightFn ?SUBPATH)
                  ?NUMBER1)))

(=>
      (and
            (equal
                  (PathWeightFn ?PATH)
                  ?SUM)
            (graphPart ?ARC1 ?PATH)
            (graphPart ?ARC2 ?PATH)
            (arcWeight ?ARC1 ?NUMBER1)
            (arcWeight ?ARC2 ?NUMBER2)
            (forall
                  (?ARC3)
                  (=>
                        (graphPart ?ARC3 ?PATH)
                        (or
                              (equal ?ARC3 ?ARC1)
                              (equal ?ARC3 ?ARC2)))))
      (equal
            (PathWeightFn ?PATH)
            (AdditionFn ?NUMBER1 ?NUMBER2)))

If "³Ì¤p¶q¸ô®|¨ç¼Æ(node1,node2)" µ¥©ó path, then path ¬O "node1 ©M node2 ¶¡ ¶°¦X¸ô®|" ªº ¹ê¨Ò.
(=>
      (equal
            (MinimalWeightedPathFn ?NODE1 ?NODE2)
            ?PATH)
      (instance
            ?PATH
            (GraphPathFn ?NODE1 ?NODE2)))

(=>
      (and
            (equal
                  (MinimalWeightedPathFn ?NODE1 ?NODE2)
                  ?PATH)
            (equal
                  (PathWeightFn ?PATH)
                  ?NUMBER))
      (forall
            (?PATH2)
            (=>
                  (and
                        (instance
                              ?PATH2
                              (GraphPathFn ?NODE1 ?NODE2))
                        (equal
                              (PathWeightFn ?PATH2)
                              ?NUMBER2))
                  (greaterThanOrEqualTo ?NUMBER2 ?NUMBER1))))

If "node1 ©M node2 ¶¡ ³Ì¤j¸ô®|" µ¥©ó path, then path ¬O "node1 ©M node2 ¶¡ ¶°¦X¸ô®|" ªº ¹ê¨Ò.
(=>
      (equal
            (MaximalWeightedPathFn ?NODE1 ?NODE2)
            ?PATH)
      (instance
            ?PATH
            (GraphPathFn ?NODE1 ?NODE2)))

(=>
      (and
            (equal
                  (MaximalWeightedPathFn ?NODE1 ?NODE2)
                  ?PATH)
            (equal
                  (PathWeightFn ?PATH)
                  ?NUMBER))
      (forall
            (?PATH2)
            (=>
                  (and
                        (instance
                              ?PATH2
                              (GraphPathFn ?NODE1 ?NODE2))
                        (equal
                              (PathWeightFn ?PATH2)
                              ?NUMBER2))
                  (lessThanOrEqualTo ?NUMBER2 ?NUMBER1))))

If path ¬O graph ªº ³¡¤À and graph ¬O ¦³¦V¹Ï ªº ¹ê¨Ò, then "node1 ©M node2 ¶¡ ¶°¦X¸ô®|" µ¥©ó path if and only if "node2 ©M node1 ¶¡ ¶°¦X¸ô®|" µ¥©ó path.
(=>
      (and
            (graphPart ?PATH ?GRAPH)
            (not
                  (instance ?GRAPH DirectedGraph)))
      (<=>
            (equal
                  (GraphPathFn ?NODE1 ?NODE2)
                  ?PATH)
            (equal
                  (GraphPathFn ?NODE2 ?NODE1)
                  ?PATH)))

If graph ¬O ¹Ï ªº ¹ê¨Ò, then "¹º¤À graph ¬° ¨â ¿W¥ß ¹Ïªí ªº ³Ì¤p¬Û¥æ¸ô®|" ¬O "¹º¤À graph ¬° ¨â ¿W¥ß ¹Ïªí ªº ¬Û¥æ¸ô®|" ªº ¦¸ºØÃþ.
(=>
      (instance ?GRAPH Graph)
      (subclass
            (MinimalCutSetFn ?GRAPH)
            (CutSetFn ?GRAPH)))

(=>
      (equal
            (MinimalCutSetFn ?GRAPH)
            ?PATHCLASS)
      (exists
            (?NUMBER)
            (forall
                  (?PATH)
                  (=>
                        (instance ?PATH ?PATHCLASS)
                        (pathLength ?PATH ?NUMBER)))))

If "number unit(s)" µ¥©ó quant and unit ¬O quanttype ªº ¦¸ºØÃþ, then quant ¬O quanttype ªº ¹ê¨Ò.
(=>
      (and
            (equal
                  (MeasureFn ?NUMBER ?UNIT)
                  ?QUANT)
            (subclass ?UNIT ?QUANTTYPE))
      (instance ?QUANT ?QUANTTYPE))

(=>
      (and
            (instance ?REL RelationExtendedToQuantities)
            (instance ?REL TernaryRelation)
            (instance ?NUMBER1 RealNumber)
            (instance ?NUMBER2 RealNumber)
            (holds ?REL ?NUMBER1 ?NUMBER2 ?VALUE))
      (forall
            (?UNIT)
            (=>
                  (instance ?UNIT UnitOfMeasure)
                  (holds
                        ?REL
                        (MeasureFn ?NUMBER1 ?UNIT)
                        (MeasureFn ?NUMBER2 ?UNIT)
                        (MeasureFn ?VALUE ?UNIT)))))

(=>
      (and
            (instance ?REL RelationExtendedToQuantities)
            (instance ?REL BinaryRelation)
            (instance ?NUMBER1 RealNumber)
            (instance ?NUMBER2 RealNumber)
            (holds ?REL ?NUMBER1 ?NUMBER2))
      (forall
            (?UNIT)
            (=>
                  (instance ?UNIT UnitOfMeasure)
                  (holds
                        ?REL
                        (MeasureFn ?NUMBER1 ?UNIT)
                        (MeasureFn ?NUMBER2 ?UNIT)))))

If unit ¬O ¶q«×³æ¦ì ªº ¹ê¨Ò, then "1 ¤d units" µ¥©ó " unit(s)".
(=>
      (instance ?UNIT UnitOfMeasure)
      (equal
            (KiloFn ?UNIT)
            (MeasureFn 1000 ?UNIT)))

If unit ¬O ¶q«×³æ¦ì ªº ¹ê¨Ò, then "1 ¦Ê¸U units" µ¥©ó " unit(s)".
(=>
      (instance ?UNIT UnitOfMeasure)
      (equal
            (MegaFn ?UNIT)
            (MeasureFn 1000000 ?UNIT)))

If unit ¬O ¶q«×³æ¦ì ªº ¹ê¨Ò, then "1 ¤Q»õ units" µ¥©ó " unit(s)".
(=>
      (instance ?UNIT UnitOfMeasure)
      (equal
            (GigaFn ?UNIT)
            (MeasureFn 1000000000 ?UNIT)))

If unit ¬O ¶q«×³æ¦ì ªº ¹ê¨Ò, then "1 ¥ü units" µ¥©ó " unit(s)".
(=>
      (instance ?UNIT UnitOfMeasure)
      (equal
            (TeraFn ?UNIT)
            (MeasureFn 1000000000000 ?UNIT)))

If unit ¬O ¶q«×³æ¦ì ªº ¹ê¨Ò, then "unit ªº ¤d¤À¤§¤@" µ¥©ó " unit(s)".
(=>
      (instance ?UNIT UnitOfMeasure)
      (equal
            (MilliFn ?UNIT)
            (MeasureFn 0.001 ?UNIT)))

If unit ¬O ¶q«×³æ¦ì ªº ¹ê¨Ò, then "unit ªº ¦Ê¸U¤À¤§¤@" µ¥©ó " unit(s)".
(=>
      (instance ?UNIT UnitOfMeasure)
      (equal
            (MicroFn ?UNIT)
            (MeasureFn 0.000001 ?UNIT)))

If unit ¬O ¶q«×³æ¦ì ªº ¹ê¨Ò, then "unit ªº ¤Q»õ¤À¤§¤@" µ¥©ó " unit(s)".
(=>
      (instance ?UNIT UnitOfMeasure)
      (equal
            (NanoFn ?UNIT)
            (MeasureFn 0.000000001 ?UNIT)))

If unit ¬O ¶q«×³æ¦ì ªº ¹ê¨Ò, then "1 ªº ¥ü¤À¤§¤@ " µ¥©ó " unit(s)".
(=>
      (instance ?UNIT UnitOfMeasure)
      (equal
            (PicoFn ?UNIT)
            (MeasureFn 0.000000000001 ?UNIT)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò and unit ¬O ¶q«×³æ¦ì ªº ¹ê¨Ò, then "1 ªº ¯Å¼Æ" µ¥©ó number.
(=>
      (and
            (instance ?NUMBER RealNumber)
            (instance ?UNIT UnitOfMeasure))
      (equal
            (MagnitudeFn
                  (MeasureFn ?NUMBER ?UNIT))
            ?NUMBER))

If object ªº ´ú¶q ¬O "¦b ¤è¦V direction ¤¤ ªº ref ¨C time ¦³ distance", then object ªº ´ú¶q ¬O "¨C time ¦³ distance".
(=>
      (measure
            ?OBJECT
            (VelocityFn ?DISTANCE ?TIME ?REF ?DIRECTION))
      (measure
            ?OBJECT
            (SpeedFn ?DISTANCE ?TIME)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¤½¤À(s)" µ¥©ó ""number*" ¤½¤Ø(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Centimeter)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 0.01)
                  Meter)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number Äá¤ó(s)" µ¥©ó ""(number-)" µ´¹ï·Å¼Ð(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER CelsiusDegree)
            (MeasureFn
                  (SubtractionFn ?NUMBER 273.15)
                  KelvinDegree)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number Äá¤ó(s)" µ¥©ó """(number-)"/" µØ¤ó-«×(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER CelsiusDegree)
            (MeasureFn
                  (DivisionFn
                        (SubtractionFn ?NUMBER 32)
                        1.8)
                  FahrenheitDegree)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¤é­p(s)" µ¥©ó ""number*" ®É­p(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER DayDuration)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 24)
                  HourDuration)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ®É­p(s)" µ¥©ó ""number*" ¤À­p(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER HourDuration)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 60)
                  MinuteDuration)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¤À­p(s)" µ¥©ó ""number*" ¬í­p(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER MinuteDuration)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 60)
                  SecondDuration)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ©P­p(s)" µ¥©ó ""number*" ¤é­p(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER WeekDuration)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 7)
                  DayDuration)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¦~­p(s)" µ¥©ó ""number*" ¤é­p(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER YearDuration)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 365)
                  DayDuration)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ­ì¤l½è¶q³æ¦ì(s)" µ¥©ó ""number**" §J(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Amu)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1.6605402 E-24)
                  Gram)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¹qÀ£³æ¦ì-¹q¥ñ¯S(s)" µ¥©ó ""number**" ¥\©Î¯àªº³æ¦ì-µJº¸(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER ElectronVolt)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1.60217733 E-19)
                  Joule)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¥úÃнuªiªø³æ¦ì(s)" µ¥©ó ""number**" ¤½¤Ø(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Angstrom)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1.0 E-10)
                  Meter)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ­^¤Ø(s)" µ¥©ó ""number*" ¤½¤Ø(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Foot)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 0.3048)
                  Meter)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ­^¦T(s)" µ¥©ó ""number*" ¤½¤Ø(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Inch)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 0.0254)
                  Meter)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ­^¨½(s)" µ¥©ó ""number*" ¤½¤Ø(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Mile)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1609.344)
                  Meter)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¬ü¨î²G¶q³æ¦ì-¥[¨Ú(s)" µ¥©ó ""number*" ¤½¤É(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER UnitedStatesGallon)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 3.785411784)
                  Liter)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ®e¶q©Î²G¶q³æ¦ì(s)" µ¥©ó ""number/" ¬ü¨î²G¶q³æ¦ì-¥[¨Ú(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Quart)
            (MeasureFn
                  (DivisionFn ?NUMBER 4)
                  UnitedStatesGallon)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number «~²æ(s)" µ¥©ó ""number/" ®e¶q©Î²G¶q³æ¦ì(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Pint)
            (MeasureFn
                  (DivisionFn ?NUMBER 2)
                  Quart)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¥b«~²æ¤§¶q(s)" µ¥©ó ""number/" «~²æ(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Cup)
            (MeasureFn
                  (DivisionFn ?NUMBER 2)
                  Pint)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¯s¥q(s)" µ¥©ó ""number/" ¥b«~²æ¤§¶q(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Ounce)
            (MeasureFn
                  (DivisionFn ?NUMBER 8)
                  Cup)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ­^¨î²G¶q³æ¦ì-¥[¨Ú(s)" µ¥©ó ""number*" ¤½¤É(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER UnitedKingdomGallon)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 4.54609)
                  Liter)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ½S(s)" µ¥©ó ""number*" §J(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER PoundMass)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 453.59237)
                  Gram)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ½è¶q³æ¦ì(s)" µ¥©ó ""number*" §J(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Slug)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 14593.90)
                  Gram)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¼¯À¿¨¤«×(s)" µ¥©ó ""number*" µ´¹ï·Å¼Ð(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER RankineDegree)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1.8)
                  KelvinDegree)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¤O¶q³æ¦ì(s)" µ¥©ó ""number*" ¤Oªº³æ¦ì-¤û¹y(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER PoundForce)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 4.448222)
                  Newton)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¼ö¶qªº³æ¦ì-¥d¸ô¨½(s)" µ¥©ó ""number*" ¥\©Î¯àªº³æ¦ì-µJº¸(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Calorie)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 4.1868)
                  Joule)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ­^°ê¼ö¶q³æ¦ì-BTU(s)" µ¥©ó ""number*" ¥\©Î¯àªº³æ¦ì-µJº¸(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER BritishThermalUnit)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1055.05585262)
                  Joule)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¨¤«×(s)" µ¥©ó ""number*"¶ê©P²v/"" ©·«×(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER AngularDegree)
            (MeasureFn
                  (MultiplicationFn
                        ?NUMBER
                        (DivisionFn Pi 180))
                  Radian)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¬ü¤¸¤@¤À(s)" µ¥©ó ""number*" ¬ü¤¸¤@¤¸(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER UnitedStatesCent)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 0.01)
                  UnitedStatesDollar)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¼Ú¤¸¤@¤À(s)" µ¥©ó ""number*" ¼Ú¤¸¤@¤¸(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER EuroCent)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 0.01)
                  EuroDollar)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¦ì¤¸²Õ(s)" µ¥©ó ""number*" ¦ì¤¸(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER Byte)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 8)
                  Bit)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¤d¦ì¤¸²Õ(s)" µ¥©ó ""number*" ¦ì¤¸²Õ(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER KiloByte)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1024)
                  Byte)))

If number ¬O ¹ê¼Æ ªº ¹ê¨Ò, then "number ¦Ê¸U¦ì¤¸²Õ(s)" µ¥©ó ""number*" ¤d¦ì¤¸²Õ(s)".
(=>
      (instance ?NUMBER RealNumber)
      (equal
            (MeasureFn ?NUMBER MegaByte)
            (MeasureFn
                  (MultiplicationFn ?NUMBER 1024)
                  KiloByte)))

If obj1 ©M obj2 ¤§¶¡ ¶ZÂ÷ ¬O quant, then obj2 ©M obj1 ¤§¶¡ ¶ZÂ÷ ¬O quant.
(=>
      (distance ?OBJ1 ?OBJ2 ?QUANT)
      (distance ?OBJ2 ?OBJ1 ?QUANT))

If ¼Ð°ª(obj1,obj2,height) holds, then obj1 ¹ï obj2 ¬O ¦b...¤§¤W.
(=>
      (altitude ?OBJ1 ?OBJ2 ?HEIGHT)
      (orientation ?OBJ1 ?OBJ2 Above))

If ¼Ð°ª(obj1,obj2,height) holds, then there exists top so that obj1 ªº ³»ºÝ ¬O top and top ©M obj2 ¤§¶¡ ¶ZÂ÷ ¬O height.
(=>
      (altitude ?OBJ1 ?OBJ2 ?HEIGHT)
      (exists
            (?TOP)
            (and
                  (top ?TOP ?OBJ1)
                  (distance ?TOP ?OBJ2 ?HEIGHT))))

If ²`«×, then obj1 ¹ï obj2 ¬O ¦b...¤§¤U.
(=>
      (depth ?OBJ1 ?OBJ2 ?DEPTH)
      (orientation ?OBJ1 ?OBJ2 Below))

If ²`«×, then there exists bottom so that obj1 ªº ©³³¡ ¬O bottom and bottom ©M obj2 ¤§¶¡ ¶ZÂ÷ ¬O depth.
(=>
      (depth ?OBJ1 ?OBJ2 ?DEPTH)
      (exists
            (?BOTTOM)
            (and
                  (bottom ?BOTTOM ?OBJ1)
                  (distance ?BOTTOM ?OBJ2 ?DEPTH))))

(=>
      (larger ?OBJ1 ?OBJ2)
      (forall
            (?QUANT1 ?QUANT2)
            (=>
                  (and
                        (measure
                              ?OBJ1
                              (MeasureFn ?QUANT1 LengthMeasure))
                        (measure
                              ?OBJ2
                              (MeasureFn ?QUANT2 LengthMeasure)))
                  (greaterThan ?QUANT1 ?QUANT2))))

If point ¬O ®ÉÂI ªº ¹ê¨Ò and point µ¥©ó ®É¶¡²×ÂI/¥Ã»·, then point (¨S) µo¥Í?{s} ¦b ®É¶¡²×ÂI/¥Ã»· ¤§«e.
(=>
      (and
            (instance ?POINT TimePoint)
            (not
                  (equal ?POINT PositiveInfinity)))
      (before ?POINT PositiveInfinity))

If point ¬O ®ÉÂI ªº ¹ê¨Ò and point µ¥©ó ®É¶¡²×ÂI/¥Ã»·, then there exists otherpoint so that otherpoint ¦b point ©M ®É¶¡²×ÂI/¥Ã»· ¤§¶¡ .
(=>
      (and
            (instance ?POINT TimePoint)
            (not
                  (equal ?POINT PositiveInfinity)))
      (exists
            (?OTHERPOINT)
            (temporallyBetween ?POINT ?OTHERPOINT PositiveInfinity)))

If point ¬O ®ÉÂI ªº ¹ê¨Ò and point µ¥©ó ®É¶¡°_ÂI/¥å¥j, then ®É¶¡°_ÂI/¥å¥j (¨S) µo¥Í?{s} ¦b point ¤§«e.
(=>
      (and
            (instance ?POINT TimePoint)
            (not
                  (equal ?POINT NegativeInfinity)))
      (before NegativeInfinity ?POINT))

If point ¬O ®ÉÂI ªº ¹ê¨Ò and point µ¥©ó ®É¶¡°_ÂI/¥å¥j, then there exists otherpoint so that otherpoint ¦b ®É¶¡°_ÂI/¥å¥j ©M point ¤§¶¡ .
(=>
      (and
            (instance ?POINT TimePoint)
            (not
                  (equal ?POINT NegativeInfinity)))
      (exists
            (?OTHERPOINT)
            (temporallyBetween NegativeInfinity ?OTHERPOINT ?POINT)))

(=>
      (frequency ?PROC ?TIME1)
      (forall
            (?TIME2)
            (=>
                  (duration ?TIME2 ?TIME1)
                  (exists
                        (?POSITION)
                        (and
                              (temporalPart ?POSITION ?TIME2)
                              (holdsDuring
                                    ?POSITION
                                    (exists
                                          (?INST)
                                          (instance ?INST ?PROC))))))))

If point ¬O ®ÉÂI ªº ¹ê¨Ò, then there exists ®É¬q interval so that point ¬O interval ªº ³¡¤À.
(=>
      (instance ?POINT TimePoint)
      (exists
            (?INTERVAL)
            (and
                  (instance ?INTERVAL TimeInterval)
                  (temporalPart ?POINT ?INTERVAL))))

If interval ¬O ®É¬q ªº ¹ê¨Ò, then there exists ®ÉÂI point so that point ¬O interval ªº ³¡¤À.
(=>
      (instance ?INTERVAL TimeInterval)
      (exists
            (?POINT)
            (and
                  (instance ?POINT TimePoint)
                  (temporalPart ?POINT ?INTERVAL))))

If situation (¨S) ¬°¯u time1a(¤§¤¤) time1 and time2 ¬O time1 ªº ³¡¤À, then situation (¨S) ¬°¯u time2a(¤§¤¤) time2.
(=>
      (and
            (holdsDuring ?TIME1 ?SITUATION)
            (temporalPart ?TIME2 ?TIME1))
      (holdsDuring ?TIME2 ?SITUATION))

If rel(inst1,inst2) (¤£) ¦¨¥ßs intervala(¤§¤¤) interval and inst1 ¬O ª«½èªº ªº ¹ê¨Ò and inst2 ¬O ª«½èªº ªº ¹ê¨Ò, then inst1 (¤£) ¦s¦bs interval ´Á¶¡ and inst2 (¤£) ¦s¦bs interval ´Á¶¡.
(=>
      (and
            (holdsDuring
                  ?INTERVAL
                  (holds ?REL ?INST1 ?INST2))
            (instance ?INST1 Physical)
            (instance ?INST2 Physical))
      (and
            (time ?INST1 ?INTERVAL)
            (time ?INST2 ?INTERVAL)))

(=>
      (equal
            (BeginFn ?INTERVAL)
            ?POINT)
      (forall
            (?OTHERPOINT)
            (=>
                  (and
                        (temporalPart ?OTHERPOINT ?INTERVAL)
                        (not
                              (equal ?OTHERPOINT ?POINT)))
                  (before ?POINT ?OTHERPOINT))))

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)))))

(=>
      (equal
            (EndFn ?INTERVAL)
            ?POINT)
      (forall
            (?OTHERPOINT)
            (=>
                  (and
                        (temporalPart ?OTHERPOINT ?INTERVAL)
                        (not
                              (equal ?OTHERPOINT ?POINT)))
                  (before ?OTHERPOINT ?POINT))))

(=>
      (instance ?OBJ Object)
      (exists
            (?TIME1 ?TIME2)
            (and
                  (instance ?TIME1 TimePoint)
                  (instance ?TIME2 TimePoint)
                  (before ?TIME1 ?TIME2)
                  (forall
                        (?TIME)
                        (=>
                              (and
                                    (beforeOrEqual ?TIME1 ?TIME)
                                    (beforeOrEqual ?TIME ?TIME2))
                              (time ?OBJ ?TIME))))))

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

If point1 (¨S) µo¥Í?{s} ¦b point2 ©Î ¤§«e, then point1 (¨S) µo¥Í?{s} ¦b point2 ¤§«e or point1 µ¥©ó point2.
(=>
      (beforeOrEqual ?POINT1 ?POINT2)
      (or
            (before ?POINT1 ?POINT2)
            (equal ?POINT1 ?POINT2)))

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)))

If interval1 (¨S) µo¥Ínot(s) ¦b interval2 ´Á¶¡, then "interval1 ªº µ²§ô" (¨S) µo¥Í?{s} ¦b "interval2 ªº µ²§ô" ¤§«e and "interval2 ªº }©l" (¨S) µo¥Í?{s} ¦b "interval1 ªº }©l" ¤§«e.
(=>
      (during ?INTERVAL1 ?INTERVAL2)
      (and
            (before
                  (EndFn ?INTERVAL1)
                  (EndFn ?INTERVAL2))
            (before
                  (BeginFn ?INTERVAL2)
                  (BeginFn ?INTERVAL1))))

If "interval1 ªº }©l" µ¥©ó "interval2 ªº }©l" and "interval1 ªº µ²§ô" µ¥©ó "interval2 ªº µ²§ô", then interval1 µ¥©ó interval2.
(=>
      (and
            (equal
                  (BeginFn ?INTERVAL1)
                  (BeginFn ?INTERVAL2))
            (equal
                  (EndFn ?INTERVAL1)
                  (EndFn ?INTERVAL2)))
      (equal ?INTERVAL1 ?INTERVAL2))

If "point1 ©M point2 ªº ¶¡¶Z" µ¥©ó interval, then "interval ªº }©l" µ¥©ó point1 and "interval ªº µ²§ô" µ¥©ó point2.
(=>
      (equal
            (TimeIntervalFn ?POINT1 ?POINT2)
            ?INTERVAL)
      (and
            (equal
                  (BeginFn ?INTERVAL)
                  ?POINT1)
            (equal
                  (EndFn ?INTERVAL)
                  ?POINT2)))

If "point1 ©M point2 ªº ¶¡¶Z" µ¥©ó interval, then for all point holds: point ¦b point1 ©M point2 ©Î ¤§¶¡ if and only if point ¬O interval ªº ³¡¤À.
(=>
      (equal
            (TimeIntervalFn ?POINT1 ?POINT2)
            ?INTERVAL)
      (forall
            (?POINT)
            (<=>
                  (temporallyBetweenOrEqual ?POINT1 ?POINT ?POINT2)
                  (temporalPart ?POINT ?INTERVAL))))

If interval ¬O "±q timeclass1 ¨ì timeclass2 ªº ¦^Âk¶¡¹j" ªº ¹ê¨Ò, then there exist timeclass1 time1,timeclass2 time2 so that time1 (¨S) }©ls interval and time2 (¨S) §¹¦¨s interval.
(=>
      (instance
            ?INTERVAL
            (RecurrentTimeIntervalFn ?TIMECLASS1 ?TIMECLASS2))
      (exists
            (?TIME1 ?TIME2)
            (and
                  (instance ?TIME1 ?TIMECLASS1)
                  (instance ?TIME2 ?TIMECLASS2)
                  (starts ?TIME1 ?INTERVAL)
                  (finishes ?TIME2 ?INTERVAL))))

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 day ¬O "¤é number" ªº ¹ê¨Ò, then number ¤p©ó©Îµ¥©ó .
(=>
      (instance
            ?DAY
            (DayFn ?NUMBER ?MONTH))
      (lessThanOrEqualTo ?NUMBER 31))

If day1 ¬O "¤é number1" ªº ¹ê¨Ò and day2 ¬O "¤é number2" ªº ¹ê¨Ò and "(number2-number1)" µ¥©ó , then day1 (¨S) ¬Û±µs day2.
(=>
      (and
            (instance
                  ?DAY1
                  (DayFn ?NUMBER1 ?MONTH))
            (instance
                  ?DAY2
                  (DayFn ?NUMBER2 ?MONTH))
            (equal
                  (SubtractionFn ?NUMBER2 ?NUMBER1)
                  1))
      (meetsTemporally ?DAY1 ?DAY2))

If hour ¬O "¤p®É number" ªº ¹ê¨Ò, then number ¤p©ó .
(=>
      (instance
            ?HOUR
            (HourFn ?NUMBER ?DAY))
      (lessThan ?NUMBER 24))

If hour1 ¬O "¤p®É number1" ªº ¹ê¨Ò and hour2 ¬O "¤p®É number2" ªº ¹ê¨Ò and "(number2-number1)" µ¥©ó , then hour1 (¨S) ¬Û±µs hour2.
(=>
      (and
            (instance
                  ?HOUR1
                  (HourFn ?NUMBER1 ?DAY))
            (instance
                  ?HOUR2
                  (HourFn ?NUMBER2 ?DAY))
            (equal
                  (SubtractionFn ?NUMBER2 ?NUMBER1)
                  1))
      (meetsTemporally ?HOUR1 ?HOUR2))

If minute ¬O "¤ÀÄÁ number" ªº ¹ê¨Ò, then number ¤p©ó .
(=>
      (instance
            ?MINUTE
            (MinuteFn ?NUMBER ?HOUR))
      (lessThan ?NUMBER 60))

If minute1 ¬O "¤ÀÄÁ number1" ªº ¹ê¨Ò and minute2 ¬O "¤ÀÄÁ number2" ªº ¹ê¨Ò and "(number2-number1)" µ¥©ó , then minute1 (¨S) ¬Û±µs minute2.
(=>
      (and
            (instance
                  ?MINUTE1
                  (MinuteFn ?NUMBER1 ?HOUR))
            (instance
                  ?MINUTE2
                  (MinuteFn ?NUMBER2 ?HOUR))
            (equal
                  (SubtractionFn ?NUMBER2 ?NUMBER1)
                  1))
      (meetsTemporally ?MINUTE1 ?MINUTE2))

If second ¬O "¬íÄÁ¨ç¼Æ(number,minute)" ªº ¹ê¨Ò, then number ¤p©ó .
(=>
      (instance
            ?SECOND
            (SecondFn ?NUMBER ?MINUTE))
      (lessThan ?NUMBER 60))

If second1 ¬O "¬íÄÁ¨ç¼Æ(number1,minute)" ªº ¹ê¨Ò and second2 ¬O "¬íÄÁ¨ç¼Æ(number2,minute)" ªº ¹ê¨Ò and "(number2-number1)" µ¥©ó , then second1 (¨S) ¬Û±µs second2.
(=>
      (and
            (instance
                  ?SECOND1
                  (SecondFn ?NUMBER1 ?MINUTE))
            (instance
                  ?SECOND2
                  (SecondFn ?NUMBER2 ?MINUTE))
            (equal
                  (SubtractionFn ?NUMBER2 ?NUMBER1)
                  1))
      (meetsTemporally ?SECOND1 ?SECOND2))

If year ¬O ¦~ ªº ¹ê¨Ò, then year ªº «ùÄò ¬O " ¦~­p(s)".
(=>
      (instance ?YEAR Year)
      (duration
            ?YEAR
            (MeasureFn 1 YearDuration)))

If year1 ¬O ¦~ ªº ¹ê¨Ò and year2 ¬O ¦~ ªº ¹ê¨Ò and "(year2-year1)" µ¥©ó , then year1 (¨S) ¬Û±µs year2.
(=>
      (and
            (instance ?YEAR1 Year)
            (instance ?YEAR2 Year)
            (equal
                  (SubtractionFn ?YEAR2 ?YEAR1)
                  1))
      (meetsTemporally ?YEAR1 ?YEAR2))

If leap ¬O ¶|¦~ ªº ¹ê¨Ò and leap µ¥©ó "number ¦~(s)", then
(=>
      (and
            (instance ?LEAP LeapYear)
            (equal
                  ?LEAP
                  (MeasureFn ?NUMBER Year)))
      (or
            (and
                  (equal
                        (RemainderFn ?NUMBER 4)
                        0)
                  (not
                        (equal
                              (RemainderFn ?NUMBER 100)
                              0)))
            (equal
                  (RemainderFn ?NUMBER 400)
                  0)))

If month ¬O ¤@¤ë ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?MONTH January)
      (duration
            ?MONTH
            (MeasureFn 31 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¤@¤ë" and month2 µ¥©ó "¤ë¥÷ ¤G¤ë", then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn January ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn February ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

If "¤ë¥÷ ¤G¤ë" µ¥©ó month and year ¬O ¶|¦~ ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (and
            (equal
                  (MonthFn February ?YEAR)
                  ?MONTH)
            (not
                  (instance ?YEAR LeapYear)))
      (duration
            ?MONTH
            (MeasureFn 28 DayDuration)))

If "¤ë¥÷ ¤G¤ë" µ¥©ó month and year ¬O ¶|¦~ ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (and
            (equal
                  (MonthFn February ?YEAR)
                  ?MONTH)
            (instance ?YEAR LeapYear))
      (duration
            ?MONTH
            (MeasureFn 29 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¤G¤ë" and month2 µ¥©ó "¤ë¥÷ ¤T¤ë", then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn February ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn March ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

If month ¬O ¤T¤ë ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?MONTH March)
      (duration
            ?MONTH
            (MeasureFn 31 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¤T¤ë" and month2 µ¥©ó "¤ë¥÷ ¥|¤ë", then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn March ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn April ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

If month ¬O ¥|¤ë ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?MONTH April)
      (duration
            ?MONTH
            (MeasureFn 30 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¥|¤ë" and month2 µ¥©ó "¤ë¥÷ ¤­¤ë", then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn April ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn May ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

If month ¬O ¤­¤ë ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?MONTH May)
      (duration
            ?MONTH
            (MeasureFn 31 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¤­¤ë" and month2 µ¥©ó "¤ë¥÷ ¤»¤ë", then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn May ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn June ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

If month ¬O ¤»¤ë ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?MONTH June)
      (duration
            ?MONTH
            (MeasureFn 30 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¤»¤ë" and month2 µ¥©ó "¤ë¥÷ ¤C¤ë", then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn June ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn July ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

If month ¬O ¤C¤ë ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?MONTH July)
      (duration
            ?MONTH
            (MeasureFn 31 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¤C¤ë" and month2 µ¥©ó "¤ë¥÷ ¤K¤ë", then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn July ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn August ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

If month ¬O ¤K¤ë ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?MONTH August)
      (duration
            ?MONTH
            (MeasureFn 31 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¤K¤ë" and month2 µ¥©ó "¤ë¥÷ ¤E¤ë", then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn August ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn September ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

If month ¬O ¤E¤ë ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?MONTH September)
      (duration
            ?MONTH
            (MeasureFn 30 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¤E¤ë" and month2 µ¥©ó "¤ë¥÷ ¤Q¤ë", then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn September ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn October ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

If month ¬O ¤Q¤ë ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?MONTH October)
      (duration
            ?MONTH
            (MeasureFn 31 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¤Q¤ë" and month2 µ¥©ó "¤ë¥÷ ¤Q¤@¤ë", then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn October ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn November ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

If month ¬O ¤Q¤@¤ë ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?MONTH November)
      (duration
            ?MONTH
            (MeasureFn 30 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¤Q¤@¤ë" and month2 µ¥©ó "¤ë¥÷ ¤Q¤G¤ë", then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn November ?YEAR))
            (equal
                  ?MONTH2
                  (MonthFn December ?YEAR)))
      (meetsTemporally ?MONTH1 ?MONTH2))

If month ¬O ¤Q¤G¤ë ªº ¹ê¨Ò, then month ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?MONTH December)
      (duration
            ?MONTH
            (MeasureFn 31 DayDuration)))

If month1 µ¥©ó "¤ë¥÷ ¤Q¤G¤ë" and month2 µ¥©ó "¤ë¥÷ ¤@¤ë" and year1 (¨S) ¬Û±µs year2, then month1 (¨S) ¬Û±µs month2.
(=>
      (and
            (equal
                  ?MONTH1
                  (MonthFn December ?YEAR1))
            (equal
                  ?MONTH2
                  (MonthFn January ?YEAR2))
            (meetsTemporally ?YEAR1 ?YEAR2))
      (meetsTemporally ?MONTH1 ?MONTH2))

If day ¬O ¤é ªº ¹ê¨Ò, then day ªº «ùÄò ¬O " ¤é­p(s)".
(=>
      (instance ?DAY Day)
      (duration
            ?DAY
            (MeasureFn 1 DayDuration)))

If day1 ¬O ¬P´Á¤@ ªº ¹ê¨Ò and day2 ¬O ¬P´Á¤G ªº ¹ê¨Ò and week ¬O ¶g ªº ¹ê¨Ò and day1 ¬O week ªº ³¡¤À and day2 ¬O week ªº ³¡¤À, then day1 (¨S) ¬Û±µs day2.
(=>
      (and
            (instance ?DAY1 Monday)
            (instance ?DAY2 Tuesday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

If day1 ¬O ¬P´Á¤G ªº ¹ê¨Ò and day2 ¬O ¬P´Á¤T ªº ¹ê¨Ò and week ¬O ¶g ªº ¹ê¨Ò and day1 ¬O week ªº ³¡¤À and day2 ¬O week ªº ³¡¤À, then day1 (¨S) ¬Û±µs day2.
(=>
      (and
            (instance ?DAY1 Tuesday)
            (instance ?DAY2 Wednesday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

If day1 ¬O ¬P´Á¤T ªº ¹ê¨Ò and day2 ¬O ¬P´Á¥| ªº ¹ê¨Ò and week ¬O ¶g ªº ¹ê¨Ò and day1 ¬O week ªº ³¡¤À and day2 ¬O week ªº ³¡¤À, then day1 (¨S) ¬Û±µs day2.
(=>
      (and
            (instance ?DAY1 Wednesday)
            (instance ?DAY2 Thursday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

If day1 ¬O ¬P´Á¥| ªº ¹ê¨Ò and day2 ¬O ¬P´Á¤­ ªº ¹ê¨Ò and week ¬O ¶g ªº ¹ê¨Ò and day1 ¬O week ªº ³¡¤À and day2 ¬O week ªº ³¡¤À, then day1 (¨S) ¬Û±µs day2.
(=>
      (and
            (instance ?DAY1 Thursday)
            (instance ?DAY2 Friday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

If day1 ¬O ¬P´Á¤­ ªº ¹ê¨Ò and day2 ¬O ¬P´Á¤» ªº ¹ê¨Ò and week ¬O ¶g ªº ¹ê¨Ò and day1 ¬O week ªº ³¡¤À and day2 ¬O week ªº ³¡¤À, then day1 (¨S) ¬Û±µs day2.
(=>
      (and
            (instance ?DAY1 Friday)
            (instance ?DAY2 Saturday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

If day1 ¬O ¬P´Á¤» ªº ¹ê¨Ò and day2 ¬O ¬P´Á¤é ªº ¹ê¨Ò and week ¬O ¶g ªº ¹ê¨Ò and day1 ¬O week ªº ³¡¤À and day2 ¬O week ªº ³¡¤À, then day1 (¨S) ¬Û±µs day2.
(=>
      (and
            (instance ?DAY1 Saturday)
            (instance ?DAY2 Sunday)
            (instance ?WEEK Week)
            (temporalPart ?DAY1 ?WEEK)
            (temporalPart ?DAY2 ?WEEK))
      (meetsTemporally ?DAY1 ?DAY2))

If day1 ¬O ¬P´Á¤é ªº ¹ê¨Ò and day2 ¬O ¬P´Á¤@ ªº ¹ê¨Ò and week1 ¬O ¶g ªº ¹ê¨Ò and week2 ¬O ¶g ªº ¹ê¨Ò and day1 ¬O week1 ªº ³¡¤À and day2 ¬O week2 ªº ³¡¤À and week1 (¨S) ¬Û±µs week2, then day1 (¨S) ¬Û±µs day2.
(=>
      (and
            (instance ?DAY1 Sunday)
            (instance ?DAY2 Monday)
            (instance ?WEEK1 Week)
            (instance ?WEEK2 Week)
            (temporalPart ?DAY1 ?WEEK1)
            (temporalPart ?DAY2 ?WEEK2)
            (meetsTemporally ?WEEK1 ?WEEK2))
      (meetsTemporally ?DAY1 ?DAY2))

If week ¬O ¶g ªº ¹ê¨Ò, then week ªº «ùÄò ¬O " ©P­p(s)".
(=>
      (instance ?WEEK Week)
      (duration
            ?WEEK
            (MeasureFn 1 WeekDuration)))

If hour ¬O ¤p®É ªº ¹ê¨Ò, then hour ªº «ùÄò ¬O " ®É­p(s)".
(=>
      (instance ?HOUR Hour)
      (duration
            ?HOUR
            (MeasureFn 1 HourDuration)))

If minute ¬O ¤À ªº ¹ê¨Ò, then minute ªº «ùÄò ¬O " ¤À­p(s)".
(=>
      (instance ?MINUTE Minute)
      (duration
            ?MINUTE
            (MeasureFn 1 MinuteDuration)))

If second ¬O ¬í ªº ¹ê¨Ò, then second ªº «ùÄò ¬O " ¬í­p(s)".
(=>
      (instance ?SECOND Second)
      (duration
            ?SECOND
            (MeasureFn 1 SecondDuration)))

(=>
      (equal
            (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
            ?CLASS)
      (forall
            (?TIME1 ?TIME2)
            (=>
                  (and
                        (instance ?TIME1 ?INTERVAL-TYPE)
                        (instance ?TIME2 ?CLASS))
                  (exists
                        (?DURATION)
                        (and
                              (duration ?TIME1 ?DURATION)
                              (duration ?TIME2 ?DURATION))))))

(=>
      (equal
            (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
            ?CLASS)
      (forall
            (?TIME1 ?TIME2)
            (=>
                  (and
                        (instance ?TIME1 ?CLASS)
                        (instance ?TIME2 ?CLASS)
                        (not
                              (equal ?TIME1 ?TIME2)))
                  (or
                        (meetsTemporally ?TIME1 ?TIME2)
                        (meetsTemporally ?TIME2 ?TIME1)
                        (earlier ?TIME1 ?TIME2)
                        (earlier ?TIME2 ?TIME1)))))

If "interval ¤À¸Ñ¦¨ ? interval-types" µ¥©ó class, then there exists class time so that time (¨S) }©ls interval.
(=>
      (equal
            (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
            ?CLASS)
      (exists
            (?TIME)
            (and
                  (instance ?TIME ?CLASS)
                  (starts ?TIME ?INTERVAL))))

If "interval ¤À¸Ñ¦¨ ? interval-types" µ¥©ó class, then there exists class time so that time (¨S) §¹¦¨s interval.
(=>
      (equal
            (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
            ?CLASS)
      (exists
            (?TIME)
            (and
                  (instance ?TIME ?CLASS)
                  (finishes ?TIME ?INTERVAL))))

(=>
      (equal
            (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
            ?CLASS)
      (forall
            (?TIME1)
            (=>
                  (and
                        (instance ?TIME1 ?CLASS)
                        (not
                              (finishes ?TIME1 ?INTERVAL)))
                  (exists
                        (?TIME2)
                        (and
                              (instance ?TIME2 ?CLASS)
                              (meetsTemporally ?TIME1 ?TIME2))))))

(=>
      (equal
            (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
            ?CLASS)
      (forall
            (?TIME1)
            (=>
                  (and
                        (instance ?TIME1 ?CLASS)
                        (not
                              (starts ?TIME1 ?INTERVAL)))
                  (exists
                        (?TIME2)
                        (and
                              (instance ?TIME2 ?CLASS)
                              (meetsTemporally ?TIME2 ?TIME1))))))

(=>
      (equal
            (TemporalCompositionFn ?INTERVAL ?INTERVAL-TYPE)
            ?CLASS)
      (forall
            (?TIME)
            (=>
                  (and
                        (instance ?TIME TimePoint)
                        (temporalPart ?TIME ?INTERVAL))
                  (exists
                        (?INSTANCE)
                        (and
                              (instance ?INSTANCE ?CLASS)
                              (temporalPart ?TIME ?INSTANCE))))))

If year ¬O ¦~ ªº ¹ê¨Ò, then ""year ¤À¸Ñ¦¨ ? ¤ës" ¤¤ ¹ê¨Ò ªº ¼Æ¥Ø" µ¥©ó .
(=>
      (instance ?YEAR Year)
      (equal
            (CardinalityFn
                  (TemporalCompositionFn ?YEAR Month))
            12))

If month ¬O ¤ë ªº ¹ê¨Ò and month ªº «ùÄò ¬O "number ¤é­p(s)", then ""month ¤À¸Ñ¦¨ ? ¤és" ¤¤ ¹ê¨Ò ªº ¼Æ¥Ø" µ¥©ó number.
(=>
      (and
            (instance ?MONTH Month)
            (duration
                  ?MONTH
                  (MeasureFn ?NUMBER DayDuration)))
      (equal
            (CardinalityFn
                  (TemporalCompositionFn ?MONTH Day))
            ?NUMBER))

If week ¬O ¶g ªº ¹ê¨Ò, then ""week ¤À¸Ñ¦¨ ? ¤és" ¤¤ ¹ê¨Ò ªº ¼Æ¥Ø" µ¥©ó .
(=>
      (instance ?WEEK Week)
      (equal
            (CardinalityFn
                  (TemporalCompositionFn ?WEEK Day))
            7))

If day ¬O ¤é ªº ¹ê¨Ò, then ""day ¤À¸Ñ¦¨ ? ¤p®És" ¤¤ ¹ê¨Ò ªº ¼Æ¥Ø" µ¥©ó .
(=>
      (instance ?DAY Day)
      (equal
            (CardinalityFn
                  (TemporalCompositionFn ?DAY Hour))
            24))

If hour ¬O ¤p®É ªº ¹ê¨Ò, then ""hour ¤À¸Ñ¦¨ ? ¤Às" ¤¤ ¹ê¨Ò ªº ¼Æ¥Ø" µ¥©ó .
(=>
      (instance ?HOUR Hour)
      (equal
            (CardinalityFn
                  (TemporalCompositionFn ?HOUR Minute))
            60))

If minute ¬O ¤À ªº ¹ê¨Ò, then ""minute ¤À¸Ñ¦¨ ? ¬ís" ¤¤ ¹ê¨Ò ªº ¼Æ¥Ø" µ¥©ó .
(=>
      (instance ?MINUTE Minute)
      (equal
            (CardinalityFn
                  (TemporalCompositionFn ?MINUTE Second))
            60))

If obj1 »P obj2 ¬Û³s, then obj1 (¨S) ±µÄ²s obj2 or obj1 (¨S) »P obj2 ­«Å|s.
(=>
      (connected ?OBJ1 ?OBJ2)
      (or
            (meetsSpatially ?OBJ1 ?OBJ2)
            (overlapsSpatially ?OBJ1 ?OBJ2)))

obj ¬O ¦Û¨­³sÄòª«Åé ªº ¹ê¨Ò if and only if for all part1,part2 holds: if obj µ¥©ó "part1 ©M part2 ªº Áp¶°", then part1 »P part2 ¬Û³s.
(<=>
      (instance ?OBJ SelfConnectedObject)
      (forall
            (?PART1 ?PART2)
            (=>
                  (equal
                        ?OBJ
                        (MereologicalSumFn ?PART1 ?PART2))
                  (connected ?PART1 ?PART2))))

If obj ³¡¤À¦ì©ó region, then obj (¨S) »P region ­«Å|s.
(=>
      (partlyLocated ?OBJ ?REGION)
      (overlapsSpatially ?OBJ ?REGION))

If obj1 ¬O collªº ¦¨­û and obj2 ¬O collªº ¦¨­û and obj1 µ¥©ó obj2, then obj1 not(¨S) »P obj2 ­«Å|.
(=>
      (and
            (member ?OBJ1 ?COLL)
            (member ?OBJ2 ?COLL)
            (not
                  (equal ?OBJ1 ?OBJ2)))
      (not
            (overlapsSpatially ?OBJ1 ?OBJ2)))

If rel ¬O ®æ¦ì¨¤¦â ªº ¹ê¨Ò and rel(process,obj) (¤£) ¦¨¥ßs, then there exists time so that "process ¦b time ªº time¦ì¸m" (¨S) »P obj ­«Å|s.
(=>
      (and
            (instance ?REL CaseRole)
            (holds ?REL ?PROCESS ?OBJ))
      (exists
            (?TIME)
            (overlapsSpatially
                  (WhereFn ?PROCESS ?TIME)
                  ?OBJ)))

If obj1 ¬O obj2ªº ¥~ªí³¡¤À, then obj1 ¬O obj2 ªº ¤@ ¤º³¡ and there doesn't exist obj3 so that obj3 ¬O obj1 ªº ¤@ ¤º³¡.
(=>
      (superficialPart ?OBJ1 ?OBJ2)
      (and
            (not
                  (interiorPart ?OBJ1 ?OBJ2))
            (not
                  (exists
                        (?OBJ3)
                        (interiorPart ?OBJ3 ?OBJ1)))))

(=>
      (surface ?OBJ1 ?OBJ2)
      (forall
            (?OBJ3)
            (=>
                  (superficialPart ?OBJ3 ?OBJ2)
                  (part ?OBJ3 ?OBJ1))))

(=>
      (interiorPart ?OBJ1 ?OBJ2)
      (forall
            (?PART)
            (=>
                  (superficialPart ?PART ?OBJ2)
                  (not
                        (overlapsSpatially ?OBJ1 ?PART)))))

If object ªº ©³³¡ ¬O bottom and part ¬O object ªº ³¡¤À) and part »P bottom ¬Û³s, then part ¹ï bottom ¬O ¦b...¤§¤W.
(=>
      (and
            (bottom ?BOTTOM ?OBJECT)
            (part ?PART ?OBJECT)
            (not
                  (connected ?PART ?BOTTOM)))
      (orientation ?PART ?BOTTOM Above))

If object ªº ³»ºÝ ¬O top and part ¬O object ªº ³¡¤À) and part »P top ¬Û³s, then part ¹ï top ¬O ¦b...¤§¤U.
(=>
      (and
            (top ?TOP ?OBJECT)
            (part ?PART ?OBJECT)
            (not
                  (connected ?PART ?TOP)))
      (orientation ?PART ?TOP Below))

If object ªº °¼­± ¬O side and part ¬O object ªº ³¡¤À) and part »P side ¬Û³s, then there exists direct so that side ¹ï part ¬O direct.
(=>
      (and
            (side ?SIDE ?OBJECT)
            (part ?PART ?OBJECT)
            (not
                  (connected ?PART ?SIDE)))
      (exists
            (?DIRECT)
            (orientation ?SIDE ?PART ?DIRECT)))

If object ªº °ª«× ¬O height and object ªº ³»ºÝ ¬O top and object ªº ©³³¡ ¬O bottom, then top ©M bottom ¤§¶¡ ¶ZÂ÷ ¬O height.
(=>
      (and
            (height ?OBJECT ?HEIGHT)
            (top ?TOP ?OBJECT)
            (bottom ?BOTTOM ?OBJECT))
      (distance ?TOP ?BOTTOM ?HEIGHT))

If obj3 µ¥©ó "obj1 ©M obj2 ªº Áp¶°", then for all part holds: part ¬O obj3 ªº ³¡¤À) if and only if part ¬O obj1 ªº ³¡¤À) or part ¬O obj2 ªº ³¡¤À).
(=>
      (equal
            ?OBJ3
            (MereologicalSumFn ?OBJ1 ?OBJ2))
      (forall
            (?PART)
            (<=>
                  (part ?PART ?OBJ3)
                  (or
                        (part ?PART ?OBJ1)
                        (part ?PART ?OBJ2)))))

If obj3 µ¥©ó "obj1 ©M obj2 ªº ¥æ¶°", then for all part holds: part ¬O obj3 ªº ³¡¤À) if and only if part ¬O obj1 ªº ³¡¤À) and part ¬O obj2 ªº ³¡¤À).
(=>
      (equal
            ?OBJ3
            (MereologicalProductFn ?OBJ1 ?OBJ2))
      (forall
            (?PART)
            (<=>
                  (part ?PART ?OBJ3)
                  (and
                        (part ?PART ?OBJ1)
                        (part ?PART ?OBJ2)))))

If obj3 µ¥©ó "obj1 ©M obj2 ªº ®t²§", then for all part holds: part ¬O obj3 ªº ³¡¤À) if and only if part ¬O obj1 ªº ³¡¤À) and part ¬O obj2 ªº ³¡¤À).
(=>
      (equal
            ?OBJ3
            (MereologicalDifferenceFn ?OBJ1 ?OBJ2))
      (forall
            (?PART)
            (<=>
                  (part ?PART ?OBJ3)
                  (and
                        (part ?PART ?OBJ1)
                        (not
                              (part ?PART ?OBJ2))))))

If hole ¦b obj ¬O ¬}, then obj ¬O ¬} ªº ¹ê¨Ò.
(=>
      (hole ?HOLE ?OBJ)
      (not
            (instance ?OBJ Hole)))

If hole ¦b obj ¬O ¬}, then hole not(¨S) »P obj ­«Å|.
(=>
      (hole ?HOLE ?OBJ)
      (not
            (overlapsSpatially ?HOLE ?OBJ)))

If hole ¦b obj1 ¬O ¬} and hole ¦b obj2 ¬O ¬}, then there exists obj3 so that obj3 ¬O "obj1 ©M obj2 ªº ¥æ¶°" ªº ¥¿³¡¤À and hole ¦b obj3 ¬O ¬}.
(=>
      (and
            (hole ?HOLE ?OBJ1)
            (hole ?HOLE ?OBJ2))
      (exists
            (?OBJ3)
            (and
                  (properPart
                        ?OBJ3
                        (MereologicalProductFn ?OBJ1 ?OBJ2))
                  (hole ?HOLE ?OBJ3))))

(=>
      (and
            (hole ?HOLE1 ?OBJ)
            (hole ?HOLE2 ?OBJ))
      (forall
            (?HOLE3)
            (=>
                  (part
                        ?HOLE3
                        (MereologicalSumFn ?HOLE1 ?HOLE2))
                  (hole ?HOLE3 ?OBJ))))

If hole ¦b obj1 ¬O ¬} and obj1 ¬O obj2 ªº ³¡¤À), then hole (¨S) »P obj2 ­«Å|s or hole ¦b obj2 ¬O ¬}.
(=>
      (and
            (hole ?HOLE ?OBJ1)
            (part ?OBJ1 ?OBJ2))
      (or
            (overlapsSpatially ?HOLE ?OBJ2)
            (hole ?HOLE ?OBJ2)))

If hole1 ¦b obj1 ¬O ¬} and hole2 ¦b obj2 ¬O ¬} and hole1 (¨S) »P hole2 ­«Å|s, then obj1 (¨S) »P obj2 ­«Å|s.
(=>
      (and
            (hole ?HOLE1 ?OBJ1)
            (hole ?HOLE2 ?OBJ2)
            (overlapsSpatially ?HOLE1 ?HOLE2))
      (overlapsSpatially ?OBJ1 ?OBJ2))

If hole1 ¬O ¬} ªº ¹ê¨Ò, then there exists hole2 so that hole2 ¬O hole1 ªº ¥¿³¡¤À.
(=>
      (instance ?HOLE1 Hole)
      (exists
            (?HOLE2)
            (properPart ?HOLE2 ?HOLE1)))

If obj1 µ¥©ó "¬} hole ªº ¥DÅé", then for all obj2 holds: obj2 (¨S) »P obj1 ­«Å|s if and only if there exists obj3 so that hole ¦b obj3 ¬O ¬} and obj2 (¨S) »P obj3 ­«Å|s.
(=>
      (equal
            ?OBJ1
            (PrincipalHostFn ?HOLE))
      (forall
            (?OBJ2)
            (<=>
                  (overlapsSpatially ?OBJ2 ?OBJ1)
                  (exists
                        (?OBJ3)
                        (and
                              (hole ?HOLE ?OBJ3)
                              (overlapsSpatially ?OBJ2 ?OBJ3))))))

If hole ¦b obj ¬O ¬}, then hole »P obj ¬Û³s.
(=>
      (hole ?HOLE ?OBJ)
      (connected ?HOLE ?OBJ))

If hole1 ¬O ¬} ªº ¹ê¨Ò and hole2 ¬O hole1 ªº ¥¿³¡¤À, then there exists obj so that hole1 (¨S) ±µÄ²s obj and hole2 not(¨S) ±µÄ² obj.
(=>
      (and
            (instance ?HOLE1 Hole)
            (properPart ?HOLE2 ?HOLE1))
      (exists
            (?OBJ)
            (and
                  (meetsSpatially ?HOLE1 ?OBJ)
                  (not
                        (meetsSpatially ?HOLE2 ?OBJ)))))

If there exists time so that obj (¨S) ¶ñ¥Rs hole timea(¤§¤¤) time, then ¥i¶ñ¥Rªº ¬O hole ªº ÄÝ©Ê.
(=>
      (exists
            (?TIME)
            (holdsDuring
                  ?TIME
                  (fills ?OBJ ?HOLE)))
      (attribute ?HOLE Fillable))

If obj (¨S) ³¡¤À¶ñ¥Rs hole1, then there exists hole2 so that hole2 ¬O hole1 ªº ³¡¤À) and obj (¨S) ¶ñ¥Rs hole2.
(=>
      (partiallyFills ?OBJ ?HOLE1)
      (exists
            (?HOLE2)
            (and
                  (part ?HOLE2 ?HOLE1)
                  (completelyFills ?OBJ ?HOLE2))))

If obj (¨S) ¾A·í¶ñ¥Rs hole1, then there exists hole2 so that hole2 ¬O hole1 ªº ³¡¤À) and obj (¨S) ¶ñ¥Rs hole2.
(=>
      (properlyFills ?OBJ ?HOLE1)
      (exists
            (?HOLE2)
            (and
                  (part ?HOLE2 ?HOLE1)
                  (fills ?OBJ ?HOLE2))))

If obj1 (¨S) ¶ñ¥Rs hole, then there exists obj2 so that obj2 ¬O obj1 ªº ³¡¤À) and obj2 (¨S) ¶ñ¥Rs hole.
(=>
      (completelyFills ?OBJ1 ?HOLE)
      (exists
            (?OBJ2)
            (and
                  (part ?OBJ2 ?OBJ1)
                  (fills ?OBJ2 ?HOLE))))

If obj1 (¨S) ¶ñ¥Rs hole and ¥i¶ñ¥Rªº ¬O obj2 ªº ÄÝ©Ê, then obj1 not(¨S) »P obj2 ­«Å|.
(=>
      (and
            (fills ?OBJ1 ?HOLE)
            (attribute ?OBJ2 Fillable))
      (not
            (overlapsSpatially ?OBJ1 ?OBJ2)))

(=>
      (completelyFills ?OBJ1 ?HOLE)
      (forall
            (?OBJ2)
            (=>
                  (connected ?OBJ2 ?HOLE)
                  (connected ?OBJ2 ?OBJ1))))

If obj1 (¨S) ¾A·í¶ñ¥Rs hole and obj2 »P obj1 ¬Û³s, then hole »P obj2 ¬Û³s.
(=>
      (and
            (properlyFills ?OBJ1 ?HOLE)
            (connected ?OBJ2 ?OBJ1))
      (connected ?HOLE ?OBJ2))

If obj (¨S) ¶ñ¥Rs hole1 and hole2 ¬O hole1 ªº ¥¿³¡¤À, then obj (¨S) ¶ñ¥Rs hole2.
(=>
      (and
            (fills ?OBJ ?HOLE1)
            (properPart ?HOLE2 ?HOLE1))
      (completelyFills ?OBJ ?HOLE2))

If obj1 (¨S) ¶ñ¥Rs hole and obj2 ¬O obj1 ªº ¥¿³¡¤À, then obj2 (¨S) ¾A·í¶ñ¥Rs hole.
(=>
      (and
            (fills ?OBJ1 ?HOLE)
            (properPart ?OBJ2 ?OBJ1))
      (properlyFills ?OBJ2 ?HOLE))

If obj1 µ¥©ó "¬} hole ªº ªí¥Ö", then for all obj2 holds: obj2 (¨S) »P obj1 ­«Å|s if and only if there exists obj3 so that obj3 ¬O "¬} hole ªº ¥DÅé"ªº ¥~ªí³¡¤À and hole (¨S) ±µÄ²s obj3 and obj2 (¨S) »P obj3 ­«Å|s.
(=>
      (equal
            ?OBJ1
            (SkinFn ?HOLE))
      (forall
            (?OBJ2)
            (<=>
                  (overlapsSpatially ?OBJ2 ?OBJ1)
                  (exists
                        (?OBJ3)
                        (and
                              (superficialPart
                                    ?OBJ3
                                    (PrincipalHostFn ?HOLE))
                              (meetsSpatially ?HOLE ?OBJ3)
                              (overlapsSpatially ?OBJ2 ?OBJ3))))))

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))))

(=>
      (subProcess ?SUBPROC ?PROC)
      (forall
            (?REGION)
            (=>
                  (located ?PROC ?REGION)
                  (located ?SUBPROC ?REGION))))

If proc ¬O ¾úµ{ ªº ¹ê¨Ò and subproc ¬O proc ªº ¦¸¾úµ{, then there exists time so that subproc (¤£) ¦s¦bs time ´Á¶¡.
(=>
      (and
            (instance ?PROC Process)
            (subProcess ?SUBPROC ?PROC))
      (exists
            (?TIME)
            (time ?SUBPROC ?TIME)))

If proc ¬O ¥Íª«¾úµ{ ªº ¹ê¨Ò, then there exists ¥Íª«Åé obj so that proc ¦ì©ó obj.
(=>
      (instance ?PROC BiologicalProcess)
      (exists
            (?OBJ)
            (and
                  (instance ?OBJ Organism)
                  (located ?PROC ?OBJ))))

If proc ¬O ¥Íª«¾úµ{ ªº ¹ê¨Ò and org (¨S) ÅéÅçnot(s) proc, then org ¬O ¥Íª«Åé ªº ¹ê¨Ò.
(=>
      (and
            (instance ?PROC BiologicalProcess)
            (experiencer ?PROC ?ORG))
      (instance ?ORG Organism))

If birth ¬O ½Ï¥Í ªº ¹ê¨Ò and agent (¨S) ÅéÅçnot(s) birth, then there exists ¦º¤` death so that agent (¨S) ÅéÅçnot(s) death.
(=>
      (and
            (instance ?BIRTH Birth)
            (experiencer ?BIRTH ?AGENT))
      (exists
            (?DEATH)
            (and
                  (instance ?DEATH Death)
                  (experiencer ?DEATH ?AGENT))))

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 act ¬O Äá­¹ ªº ¹ê¨Ò and food ¬O act ªº ¨ü¨ÆªÌ, then food ¬O ­¹ª« ªº ¹ê¨Ò.
(=>
      (and
            (instance ?ACT Ingesting)
            (patient ?ACT ?FOOD))
      (instance ?FOOD Food))

If act ¬O ¦Y ªº ¹ê¨Ò and food ¬O act ªº ¨ü¨ÆªÌ, then ©TÅ骺 ¬O food ªº ÄÝ©Ê.
(=>
      (and
            (instance ?ACT Eating)
            (patient ?ACT ?FOOD))
      (attribute ?FOOD Solid))

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 digest ¬O ®ø¤Æ ªº ¹ê¨Ò, then there exists ¤Æ¾Ç¤À¸Ñ decomp so that decomp ¬O digest ªº ¦¸¾úµ{.
(=>
      (instance ?DIGEST Digesting)
      (exists
            (?DECOMP)
            (and
                  (instance ?DECOMP ChemicalDecomposition)
                  (subProcess ?DECOMP ?DIGEST))))

If rep ¬O ½Æ»s ªº ¹ê¨Ò and rep ¬O parent ªº ¬I¨ÆªÌ and child ¬O rep ªº µ²ªG, then parent ¬O child ªº Âù¿Ë.
(=>
      (and
            (instance ?REP Replication)
            (agent ?REP ?PARENT)
            (result ?REP ?CHILD))
      (parent ?CHILD ?PARENT))

If rep ¬O ½Æ»s ªº ¹ê¨Ò, then there exists ¥Í´Þºc³y body so that body ¬O rep ªº µ²ªG.
(=>
      (instance ?REP Replication)
      (exists
            (?BODY)
            (and
                  (instance ?BODY ReproductiveBody)
                  (result ?REP ?BODY))))

If rep ¬O ¦³©Ê¥Í´Þ ªº ¹ê¨Ò and organism ¬O rep ªº µ²ªG, then there don't exist mother,father so that mother ¬O organism ªº ¥À¿Ë and father ¬O organism ªº ¤÷¿Ë.
(=>
      (and
            (instance ?REP SexualReproduction)
            (result ?REP ?ORGANISM))
      (not
            (exists
                  (?MOTHER ?FATHER)
                  (and
                        (mother ?ORGANISM ?MOTHER)
                        (father ?ORGANISM ?FATHER)))))

If rep ¬O µL©Ê¥Í´Þ ªº ¹ê¨Ò and organism ¬O rep ªº µ²ªG, then there don't exist parent1,parent2 so that parent1 ¬O organism ªº Âù¿Ë and parent2 ¬O organism ªº Âù¿Ë and parent1 µ¥©ó parent2.
(=>
      (and
            (instance ?REP AsexualReproduction)
            (result ?REP ?ORGANISM))
      (not
            (exists
                  (?PARENT1 ?PARENT2)
                  (and
                        (parent ?ORGANISM ?PARENT1)
                        (parent ?ORGANISM ?PARENT2)
                        (not
                              (equal ?PARENT1 ?PARENT2))))))

If process ¬O ¤ß²z¾úµ{ ªº ¹ê¨Ò, then there exists °Êª« animal so that animal (¨S) ÅéÅçnot(s) process.
(=>
      (instance ?PROCESS PsychologicalProcess)
      (exists
            (?ANIMAL)
            (and
                  (instance ?ANIMAL Animal)
                  (experiencer ?PROCESS ?ANIMAL))))

If proc ¬O ¾¹©x©Î²Õ´¾úµ{ ªº ¹ê¨Ò, then there exists thing so that proc ¦ì©ó thing and thing ¬O ¾¹©x ªº ¹ê¨Ò or thing ¬O ²Õ´ ªº ¹ê¨Ò.
(=>
      (instance ?PROC OrganOrTissueProcess)
      (exists
            (?THING)
            (and
                  (located ?PROC ?THING)
                  (or
                        (instance ?THING Organ)
                        (instance ?THING Tissue)))))

If path ¬O ¯f²z¾úµ{ ªº ¹ê¨Ò and org (¨S) ÅéÅçnot(s) path, then there exist part,¯e¯f©Î¯g­Ô¸s disease so that part ¬O org ªº ³¡¤À) and disease ¬O part ªº ÄÝ©Ê.
(=>
      (and
            (instance ?PATH PathologicProcess)
            (experiencer ?PATH ?ORG))
      (exists
            (?PART ?DISEASE)
            (and
                  (part ?PART ?ORG)
                  (instance ?DISEASE DiseaseOrSyndrome)
                  (attribute ?PART ?DISEASE))))

If inj ¬O ¶Ë®` ªº ¹ê¨Ò, then there exists ¸Ñ­åºc³y struct so that struct ¬O inj ªº ¨ü¨ÆªÌ.
(=>
      (instance ?INJ Injuring)
      (exists
            (?STRUCT)
            (and
                  (instance ?STRUCT AnatomicalStructure)
                  (patient ?INJ ?STRUCT))))

If poison ¬O ¤¤¬r ªº ¹ê¨Ò, then there exists thing so that thing ¬O poison ªº ¨ü¨ÆªÌ and thing ¬O ¥Íª«Åé ªº ¹ê¨Ò or thing ¬O ¸Ñ­åºc³y ªº ¹ê¨Ò.
(=>
      (instance ?POISON Poisoning)
      (exists
            (?THING)
            (and
                  (patient ?POISON ?THING)
                  (or
                        (instance ?THING Organism)
                        (instance ?THING AnatomicalStructure)))))

If poison ¬O ¤¤¬r ªº ¹ê¨Ò, then there exists ¬¡©Ê¥Íª«ª«½è substance so that substance ¹ï poison ¬O ¤u¨ã.
(=>
      (instance ?POISON Poisoning)
      (exists
            (?SUBSTANCE)
            (and
                  (instance ?SUBSTANCE BiologicallyActiveSubstance)
                  (instrument ?POISON ?SUBSTANCE))))

If proc ¬O ·N¦V©Ê¾úµ{ ªº ¹ê¨Ò and proc ¬O agent ªº ¬I¨ÆªÌ, then there exists purp so that proc ¹ïagent ¦³ ·N¹Ï purp.
(=>
      (and
            (instance ?PROC IntentionalProcess)
            (agent ?PROC ?AGENT))
      (exists
            (?PURP)
            (hasPurposeForAgent ?PROC ?PURP ?AGENT)))

If proc ¬O ·N¦V©Ê¾úµ{ ªº ¹ê¨Ò, then there exists ¨ã»{ª¾¤O¬I¨ÆªÌ agent so that proc ¬O agent ªº ¬I¨ÆªÌ.
(=>
      (instance ?PROC IntentionalProcess)
      (exists
            (?AGENT)
            (and
                  (instance ?AGENT CognitiveAgent)
                  (agent ?PROC ?AGENT))))

If act ¬O ²Õ´©Êªº¾úµ{ ªº ¹ê¨Ò and act ¬O agent ªº ¬I¨ÆªÌ, then
(=>
      (and
            (instance ?ACT OrganizationalProcess)
            (agent ?ACT ?AGENT))
      (or
            (instance ?AGENT Organization)
            (exists
                  (?ORG)
                  (and
                        (instance ?ORG Organization)
                        (member ?AGENT ?ORG)))))

If act ¬O ©v±Ð¾úµ{ ªº ¹ê¨Ò and act ¬O agent ªº ¬I¨ÆªÌ, then
(=>
      (and
            (instance ?ACT ReligiousProcess)
            (agent ?ACT ?AGENT))
      (or
            (instance ?AGENT ReligiousOrganization)
            (exists
                  (?ORG)
                  (and
                        (member ?AGENT ?ORG)
                        (instance ?ORG ReligiousOrganization)))))

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 grad ¬O ²¦·~ ªº ¹ê¨Ò and grad ¬O org ªº ¬I¨ÆªÌ and person ¬O grad ªº ¨ü¨ÆªÌ, then org ¬O ±Ð¨|²Õ´ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?GRAD Graduation)
            (agent ?GRAD ?ORG)
            (patient ?GRAD ?PERSON))
      (instance ?ORG EducationalOrganization))

If mat ¬O ¥¿¦¡¤J¾Ç ªº ¹ê¨Ò and mat ¬O org ªº ¬I¨ÆªÌ and person ¬O mat ªº ¨ü¨ÆªÌ, then org ¬O ±Ð¨|²Õ´ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?MAT Matriculation)
            (agent ?MAT ?ORG)
            (patient ?MAT ?PERSON))
      (instance ?ORG EducationalOrganization))

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 proc ¬O ¬Fªv¾úµ{ ªº ¹ê¨Ò, then there exists ¬F©² gov so that proc ¬O gov ªº ¬I¨ÆªÌ or gov ¬O proc ªº ¨ü¨ÆªÌ.
(=>
      (instance ?PROC PoliticalProcess)
      (exists
            (?GOV)
            (and
                  (instance ?GOV Government)
                  (or
                        (agent ?PROC ?GOV)
                        (patient ?PROC ?GOV)))))

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)))

(=>
      (and
            (path ?PROCESS ?PATH1)
            (origin ?PROCESS ?SOURCE)
            (destination ?PROCESS ?DEST)
            (length ?PATH1 ?MEASURE1)
            (not
                  (exists
                        (?PATH2 ?MEASURE2)
                        (and
                              (path ?PROCESS ?PATH2)
                              (origin ?PROCESS ?ORIGIN)
                              (destination ?PROCESS ?DEST)
                              (length ?PATH2 ?MEASURE2)
                              (lessThan ?MEASURE2 ?MEASURE1)))))
      (forall
            (?OBJ)
            (=>
                  (part ?OBJ ?PATH1)
                  (between ?SOURCE ?OBJ ?DEST))))

If motion ¬O ¨­Åé²¾°Ê ªº ¹ê¨Ò, then there exist ÂßÅ鳡¥ó obj,¥Íª«Åé agent so that obj ¬O motion ªº ¨ü¨ÆªÌ and motion ¬O agent ªº ¬I¨ÆªÌ.
(=>
      (instance ?MOTION BodyMotion)
      (exists
            (?OBJ ?AGENT)
            (and
                  (instance ?OBJ BodyPart)
                  (patient ?MOTION ?OBJ)
                  (instance ?AGENT Organism)
                  (agent ?MOTION ?AGENT))))

If walk ¬O ¦æ¨« ªº ¹ê¨Ò and walk ¬O agent ªº ¬I¨ÆªÌ, then there exists ³°¦a area so that agent ¦ì©ó area.
(=>
      (and
            (instance ?WALK Walking)
            (agent ?WALK ?AGENT))
      (exists
            (?AREA)
            (and
                  (instance ?AREA LandArea)
                  (located ?AGENT ?AREA))))

If swim ¬O ¹Cªa ªº ¹ê¨Ò and swim ¬O agent ªº ¬I¨ÆªÌ, then there exists ¤ô°ì area so that agent ¦ì©ó area.
(=>
      (and
            (instance ?SWIM Swimming)
            (agent ?SWIM ?AGENT))
      (exists
            (?AREA)
            (and
                  (instance ?AREA WaterArea)
                  (located ?AGENT ?AREA))))

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 transfer ¬O Âಾ©ÎÂà´« ªº ¹ê¨Ò and transfer ¬O agent ªº ¬I¨ÆªÌ and patient ¬O transfer ªº ¨ü¨ÆªÌ, then agent µ¥©ó patient.
(=>
      (and
            (instance ?TRANSFER Transfer)
            (agent ?TRANSFER ?AGENT)
            (patient ?TRANSFER ?PATIENT))
      (not
            (equal ?AGENT ?PATIENT)))

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 sub ¬O ´À´« ªº ¹ê¨Ò, then there exist ©ñ¸m put,²¾°£ remove,obj1,obj2,place so that put ¬O sub ªº ¦¸¾úµ{ and remove ¬O sub ªº ¦¸¾úµ{ and obj1 ¬O remove ªº ¨ü¨ÆªÌ and remove (¤£) °_·½s ©ó place and obj2 ¬O put ªº ¨ü¨ÆªÌ and put (¤£) ²×µ²not(s) place and obj1 µ¥©ó obj2.
(=>
      (instance ?SUB Substituting)
      (exists
            (?PUT ?REMOVE ?OBJ1 ?OBJ2 ?PLACE)
            (and
                  (instance ?PUT Putting)
                  (instance ?REMOVE Removing)
                  (subProcess ?PUT ?SUB)
                  (subProcess ?REMOVE ?SUB)
                  (patient ?REMOVE ?OBJ1)
                  (origin ?REMOVE ?PLACE)
                  (patient ?PUT ?OBJ2)
                  (destination ?PUT ?PLACE)
                  (not
                        (equal ?OBJ1 ?OBJ2)))))

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 trans ¬O ¹B¿é ªº ¹ê¨Ò, then there exists ¹B¿é¤u¨ã device so that device ¹ï trans ¬O ¤u¨ã.
(=>
      (instance ?TRANS Transportation)
      (exists
            (?DEVICE)
            (and
                  (instance ?DEVICE TransportationDevice)
                  (instrument ?TRANS ?DEVICE))))

If steer ¬O ¤Þ¾É ªº ¹ê¨Ò, then there exists ¹B¿é¤u¨ã vehicle so that vehicle ¬O steer ªº ¨ü¨ÆªÌ.
(=>
      (instance ?STEER Steering)
      (exists
            (?VEHICLE)
            (and
                  (instance ?VEHICLE TransportationDevice)
                  (patient ?STEER ?VEHICLE))))

If education ¬O ±Ð¨|¾úµ{ ªº ¹ê¨Ò and person ¬O education ªº ¨ü¨ÆªÌ, then education ¦³ ·N¹Ï "there exists ¾Ç²ß learn so that person ¬O learn ªº ¨ü¨ÆªÌ".
(=>
      (and
            (instance ?EDUCATION EducationalProcess)
            (patient ?EDUCATION ?PERSON))
      (hasPurpose
            ?EDUCATION
            (exists
                  (?LEARN)
                  (and
                        (instance ?LEARN Learning)
                        (patient ?LEARN ?PERSON)))))

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 give ¬O µ¹»P ªº ¹ê¨Ò and give ¬O agent1 ªº ¬I¨ÆªÌ and give (¤£) ²×µ²not(s) agent2 and agent2 ¬O ¬I¨ÆªÌ ªº ¹ê¨Ò and obj ¬O give ªº ¨ü¨ÆªÌ, then there exists Àò¨ú get so that get ¬O agent2 ªº ¬I¨ÆªÌ and get (¤£) °_·½s ©ó agent1 and obj ¬O get ªº ¨ü¨ÆªÌ.
(=>
      (and
            (instance ?GIVE Giving)
            (agent ?GIVE ?AGENT1)
            (destination ?GIVE ?AGENT2)
            (instance ?AGENT2 Agent)
            (patient ?GIVE ?OBJ))
      (exists
            (?GET)
            (and
                  (instance ?GET Getting)
                  (agent ?GET ?AGENT2)
                  (origin ?GET ?AGENT1)
                  (patient ?GET ?OBJ))))

If give ¬O µ¹»P ªº ¹ê¨Ò and give ¬O agent ªº ¬I¨ÆªÌ, then give (¤£) °_·½s ©ó agent.
(=>
      (and
            (instance ?GIVE Giving)
            (agent ?GIVE ?AGENT))
      (origin ?GIVE ?AGENT))

If give ¬O ³æ¤è­±ªºµ¹»P ªº ¹ê¨Ò, then there doesn't exist ¥æ©ö trans so that give ¬O trans ªº ¦¸¾úµ{.
(=>
      (instance ?GIVE UnilateralGiving)
      (not
            (exists
                  (?TRANS)
                  (and
                        (instance ?TRANS Transaction)
                        (subProcess ?GIVE ?TRANS)))))

If get ¬O Àò¨ú ªº ¹ê¨Ò and get ¬O agent ªº ¬I¨ÆªÌ, then get (¤£) ²×µ²not(s) agent.
(=>
      (and
            (instance ?GET Getting)
            (agent ?GET ?AGENT))
      (destination ?GET ?AGENT))

If get ¬O ³æ¤è­±ªºÀò¨ú ªº ¹ê¨Ò, then there doesn't exist ¥æ©ö trans so that get ¬O trans ªº ¦¸¾úµ{.
(=>
      (instance ?GET UnilateralGetting)
      (not
            (exists
                  (?TRANS)
                  (and
                        (instance ?TRANS Transaction)
                        (subProcess ?GET ?TRANS)))))

If trans ¬O ¥æ©ö ªº ¹ê¨Ò, then there exist agent1,agent2,µ¹»P give1,µ¹»P give2,obj1,obj2 so that give1 ¬O trans ªº ¦¸¾úµ{ and give2 ¬O trans ªº ¦¸¾úµ{ and give1 ¬O agent1 ªº ¬I¨ÆªÌ and give2 ¬O agent2 ªº ¬I¨ÆªÌ and obj1 ¬O give1 ªº ¨ü¨ÆªÌ and obj2 ¬O give2 ªº ¨ü¨ÆªÌ and give1 (¤£) ²×µ²not(s) agent2 and give2 (¤£) ²×µ²not(s) agent1 and agent1 µ¥©ó agent2 and obj1 µ¥©ó obj2.
(=>
      (instance ?TRANS Transaction)
      (exists
            (?AGENT1 ?AGENT2 ?GIVE1 ?GIVE2 ?OBJ1 ?OBJ2)
            (and
                  (instance ?GIVE1 Giving)
                  (instance ?GIVE2 Giving)
                  (subProcess ?GIVE1 ?TRANS)
                  (subProcess ?GIVE2 ?TRANS)
                  (agent ?GIVE1 ?AGENT1)
                  (agent ?GIVE2 ?AGENT2)
                  (patient ?GIVE1 ?OBJ1)
                  (patient ?GIVE2 ?OBJ2)
                  (destination ?GIVE1 ?AGENT2)
                  (destination ?GIVE2 ?AGENT1)
                  (not
                        (equal ?AGENT1 ?AGENT2))
                  (not
                        (equal ?OBJ1 ?OBJ2)))))

If trans ¬O ª÷¿Ä¥æ©ö ªº ¹ê¨Ò, then there exists ¶×²v³æ¦ì obj so that obj ¬O trans ªº ¨ü¨ÆªÌ.
(=>
      (instance ?TRANS FinancialTransaction)
      (exists
            (?OBJ)
            (and
                  (patient ?TRANS ?OBJ)
                  (instance ?OBJ CurrencyMeasure))))

If buy ¬O ¶R ªº ¹ê¨Ò and buy ¬O agent ªº ¬I¨ÆªÌ, then buy (¤£) ²×µ²not(s) agent.
(=>
      (and
            (instance ?BUY Buying)
            (agent ?BUY ?AGENT))
      (destination ?BUY ?AGENT))

If sell ¬O ¾P°â ªº ¹ê¨Ò and sell ¬O agent ªº ¬I¨ÆªÌ, then sell (¤£) °_·½s ©ó agent.
(=>
      (and
            (instance ?SELL Selling)
            (agent ?SELL ?AGENT))
      (origin ?SELL ?AGENT))

If learn ¬O ¾Ç²ß ªº ¹ê¨Ò and learn ¬O agent ªº ¬I¨ÆªÌ, then agent ¬O ¨ã»{ª¾¤O¬I¨ÆªÌ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?LEARN Learning)
            (agent ?LEARN ?AGENT))
      (instance ?AGENT CognitiveAgent))

If there exists ¾Ç²ß learn so that learn ¬O agent ªº ¬I¨ÆªÌ and prop ¬O learn ªº ¨ü¨ÆªÌ timea(¤§¤¤) time, then agent (¤£)¬Û«H prop "time ¤£¤[ ¤§«á"a(¤§¤¤) time ¤£¤[ ¤§«á.
(=>
      (holdsDuring
            ?TIME
            (exists
                  (?LEARN)
                  (and
                        (instance ?LEARN Learning)
                        (agent ?LEARN ?AGENT)
                        (patient ?LEARN ?PROP))))
      (holdsDuring
            (ImmediateFutureFn ?TIME)
            (believes ?AGENT ?PROP)))

If agent ¬O ¨ã»{ª¾¤O¬I¨ÆªÌ ªº ¹ê¨Ò, then agent ¥i¥H ¥ô¨¤¦â ¬I¨ÆªÌ °µ ±À²z.
(=>
      (instance ?AGENT CognitiveAgent)
      (capability Reasoning agent ?AGENT))

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 count ¬O ­p¼Æ ªº ¹ê¨Ò and count ¬O agent ªº ¬I¨ÆªÌ and entity ¬O count ªº ¨ü¨ÆªÌ, then there exists number so that agent (¤£¡^ª¾¹Ds) %2.
(=>
      (and
            (instance ?COUNT Counting)
            (agent ?COUNT ?AGENT)
            (patient ?COUNT ?ENTITY))
      (exists
            (?NUMBER)
            (knows
                  ?AGENT
                  (equal
                        (CardinalityFn ?ENTITY)
                        ?NUMBER))))

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 confine ¬O ­­©w ªº ¹ê¨Ò, then there exists ¤HÃþ human so that human ¬O confine ªº ¨ü¨ÆªÌ.
(=>
      (instance ?CONFINE Confining)
      (exists
            (?HUMAN)
            (and
                  (instance ?HUMAN Human)
                  (patient ?CONFINE ?HUMAN))))

If confine ¬O ­­©w ªº ¹ê¨Ò and person ¬O confine ªº ¨ü¨ÆªÌ, then person not(¤£) ¾¬¨D(s) "person ¬O confine ªº ¨ü¨ÆªÌ".
(=>
      (and
            (instance ?CONFINE Confining)
            (patient ?CONFINE ?PERSON))
      (not
            (desires
                  ?PERSON
                  (patient ?CONFINE ?PERSON))))

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)))))

If proc ¬O ªvÀø¾úµ{ ªº ¹ê¨Ò and bio ¬O proc ªº ¨ü¨ÆªÌ, then
(=>
      (and
            (instance ?PROC TherapeuticProcess)
            (patient ?PROC ?BIO))
      (or
            (instance ?BIO Organism)
            (exists
                  (?ORG)
                  (and
                        (instance ?ORG Organism)
                        (part ?BIO ?ORG)))))

If act ¬O ¥~¬ì¤â³N ªº ¹ê¨Ò and animal ¬O act ªº ¨ü¨ÆªÌ, then there exists ¤Á³Î subact so that animal ¬O °Êª« ªº ¹ê¨Ò and cutting ¬O animal ªº ¨ü¨ÆªÌ and subact ¬O act ªº ¦¸¾úµ{.
(=>
      (and
            (instance ?ACT Surgery)
            (patient ?ACT ?ANIMAL))
      (exists
            (?SUBACT)
            (and
                  (instance ?SUBACT Cutting)
                  (instance ?ANIMAL Animal)
                  (patient ?ANIMAL ?CUTTING)
                  (subProcess ?SUBACT ?ACT))))

If kill ¬O ±þ®` ªº ¹ê¨Ò and kill ¬O agent ªº ¬I¨ÆªÌ and patient ¬O kill ªº ¨ü¨ÆªÌ, then agent ¬O ¥Íª«Åé ªº ¹ê¨Ò and patient ¬O ¥Íª«Åé ªº ¹ê¨Ò.
(=>
      (and
            (instance ?KILL Killing)
            (agent ?KILL ?AGENT)
            (patient ?KILL ?PATIENT))
      (and
            (instance ?AGENT Organism)
            (instance ?PATIENT Organism)))

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)))))

If , then stuff ¬O ¯Âª«½è ªº ¹ê¨Ò.
(=>
      (and
            (instance ?PROC ChemicalProcess)
            (or
                  (resource ?PROC ?STUFF)
                  (result ?PROC ?STUFF)))
      (instance ?STUFF PureSubstance))

If substance1 ¹ï proc ¬O ¸ê·½ and substance2 ¬O proc ªº µ²ªG and substance1 ¬O °ò¥»ª«½è ªº ¹ê¨Ò and substance2 ¬O ¤Æ¦Xª« ªº ¹ê¨Ò, then proc ¬O ¤Æ¾Ç¦X¦¨ ªº ¹ê¨Ò.
(=>
      (and
            (resource ?PROC ?SUBSTANCE1)
            (result ?PROC ?SUBSTANCE2)
            (instance ?SUBSTANCE1 ElementalSubstance)
            (instance ?SUBSTANCE2 CompoundSubstance))
      (instance ?PROC ChemicalSynthesis))

If substance1 ¹ï proc ¬O ¸ê·½ and substance2 ¬O proc ªº µ²ªG and substance1 ¬O ¤Æ¦Xª« ªº ¹ê¨Ò and substance2 ¬O °ò¥»ª«½è ªº ¹ê¨Ò, then proc ¬O ¤Æ¾Ç¤À¸Ñ ªº ¹ê¨Ò.
(=>
      (and
            (resource ?PROC ?SUBSTANCE1)
            (result ?PROC ?SUBSTANCE2)
            (instance ?SUBSTANCE1 CompoundSubstance)
            (instance ?SUBSTANCE2 ElementalSubstance))
      (instance ?PROC ChemicalDecomposition))

If combustion ¬O ¿U¿N ªº ¹ê¨Ò, then there exist ¥[·Å heat,¥ú½u light so that heat ¬O combustion ªº ¦¸¾úµ{ and light ¬O combustion ªº ¦¸¾úµ{.
(=>
      (instance ?COMBUSTION Combustion)
      (exists
            (?HEAT ?LIGHT)
            (and
                  (instance ?HEAT Heating)
                  (instance ?LIGHT RadiatingLight)
                  (subProcess ?HEAT ?COMBUSTION)
                  (subProcess ?LIGHT ?COMBUSTION))))

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 develop ¬O ¤º®eµo®i ªº ¹ê¨Ò, then there exists ¤º®e¸üÅé obj so that obj ¬O develop ªº ¨ü¨ÆªÌ.
(=>
      (instance ?DEVELOP ContentDevelopment)
      (exists
            (?OBJ)
            (and
                  (instance ?OBJ ContentBearingObject)
                  (patient ?DEVELOP ?OBJ))))

If read ¬O ¾\Ū ªº ¹ê¨Ò, then there exist ¤å¥» text,prop so that text (¤£) ¥]§ts) °T®§ %2 and read ªí¹F prop ªº ¤º®e.
(=>
      (instance ?READ Reading)
      (exists
            (?TEXT ?PROP)
            (and
                  (instance ?TEXT Text)
                  (containsInformation ?TEXT ?PROP)
                  (realization ?READ ?PROP))))

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 wet ¬O Àã¼í ªº ¹ê¨Ò, then there exists obj so that ²GÅ骺 ¬O obj ªº ÄÝ©Ê and obj ¬O wet ªº ¨ü¨ÆªÌ.
(=>
      (instance ?WET Wetting)
      (exists
            (?OBJ)
            (and
                  (attribute ?OBJ Liquid)
                  (patient ?WET ?OBJ))))

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)))

If action ¬O ²£¥Í ªº ¹ê¨Ò, then there exists result so that result ¬O action ªº µ²ªG.
(=>
      (instance ?ACTION Creation)
      (exists
            (?RESULT)
            (result ?ACTION ?RESULT)))

If pub ¬O ¥Xª© ªº ¹ê¨Ò and text ¬O pub ªº ¨ü¨ÆªÌ, then text ¬O ¤å¥» ªº ¦¸ºØÃþ.
(=>
      (and
            (instance ?PUB Publication)
            (patient ?PUB ?TEXT))
      (subclass ?TEXT Text))

If cook ¬O ²i¶¹ ªº ¹ê¨Ò, then there exists ­¹ª« food so that food ¬O cook ªº µ²ªG.
(=>
      (instance ?COOK Cooking)
      (exists
            (?FOOD)
            (and
                  (instance ?FOOD Food)
                  (result ?COOK ?FOOD))))

If search ¬O ±´´M ªº ¹ê¨Ò and search ¬O agent ªº ¬I¨ÆªÌ and entity ¬O search ªº ¨ü¨ÆªÌ, then agent ¦b entity ½d³ò¤¤.
(=>
      (and
            (instance ?SEARCH Searching)
            (agent ?SEARCH ?AGENT)
            (patient ?SEARCH ?ENTITY))
      (inScopeOfInterest ?AGENT ?ENTITY))

If pursue ¬O °l ªº ¹ê¨Ò and pursue ¬O agent ªº ¬I¨ÆªÌ and obj ¬O pursue ªº ¨ü¨ÆªÌ, then agent (¤£) ·Q­nnot(s) obj pursuea(¤§¤¤) pursue.
(=>
      (and
            (instance ?PURSUE Pursuing)
            (agent ?PURSUE ?AGENT)
            (patient ?PURSUE ?OBJ))
      (holdsDuring
            ?PURSUE
            (wants ?AGENT ?OBJ)))

If pursue ¬O °l ªº ¹ê¨Ò and pursue ¬O agent ªº ¬I¨ÆªÌ and obj ¬O pursue ªº ¨ü¨ÆªÌ, then agent not(¨S) ¾Ö¦³(s) obj pursuea(¤§¤¤) pursue.
(=>
      (and
            (instance ?PURSUE Pursuing)
            (agent ?PURSUE ?AGENT)
            (patient ?PURSUE ?OBJ))
      (holdsDuring
            ?PURSUE
            (not
                  (possesses ?AGENT ?OBJ))))

If investigate ¬O ½Õ¬d ªº ¹ê¨Ò and prop ¬O investigate ªº ¨ü¨ÆªÌ, then prop ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?INVESTIGATE Investigating)
            (patient ?INVESTIGATE ?PROP))
      (instance ?PROP Formula))

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 proc ¬O ¶EÂ_¾úµ{ ªº ¹ê¨Ò and proc ¬O agent ªº ¬I¨ÆªÌ, then there exists cause so that proc ¹ïagent ¦³ ·N¹Ï "agent (¤£¡^ª¾¹Ds) %2".
(=>
      (and
            (instance ?PROC DiagnosticProcess)
            (agent ?PROC ?AGENT))
      (exists
            (?CAUSE)
            (hasPurposeForAgent
                  ?PROC
                  (knows
                        ?AGENT
                        (causes ?CAUSE ?PROC))
                  ?AGENT)))

If interaction ¬O ¤H»Ú¤¬°Ê ªº ¹ê¨Ò, then there exist agent1,agent2 so that interaction ¬O agent1 ªº ¬I¨ÆªÌ and interaction ¬O agent2 ªº ¬I¨ÆªÌ and agent1 µ¥©ó agent2.
(=>
      (instance ?INTERACTION SocialInteraction)
      (exists
            (?AGENT1 ?AGENT2)
            (and
                  (agent ?INTERACTION ?AGENT1)
                  (agent ?INTERACTION ?AGENT2)
                  (not
                        (equal ?AGENT1 ?AGENT2)))))

If pretend ¬O °°¸Ë ªº ¹ê¨Ò, then there exist person,prop so that pretend ¦³ ·N¹Ï "person (¤£)¬Û«H prop" and prop &$¬O ¯uªº.
(=>
      (instance ?PRETEND Pretending)
      (exists
            (?PERSON ?PROP)
            (and
                  (hasPurpose
                        ?PRETEND
                        (believes ?PERSON ?PROP))
                  (true ?PROP True))))

If communicate ¬O ·¾³q ªº ¹ê¨Ò, then there exist ¤º®e¸üÅé obj,¨ã»{ª¾¤O¬I¨ÆªÌ agent1,¨ã»{ª¾¤O¬I¨ÆªÌ agent2 so that obj ¬O communicate ªº ¨ü¨ÆªÌ and communicate ¬O agent1 ªº ¬I¨ÆªÌ and communicate (¤£) ²×µ²not(s) agent2.
(=>
      (instance ?COMMUNICATE Communication)
      (exists
            (?OBJ ?AGENT1 ?AGENT2)
            (and
                  (instance ?OBJ ContentBearingObject)
                  (patient ?COMMUNICATE ?OBJ)
                  (instance ?AGENT1 CognitiveAgent)
                  (agent ?COMMUNICATE ?AGENT1)
                  (instance ?AGENT2 CognitiveAgent)
                  (destination ?COMMUNICATE ?AGENT2))))

If disseminate ¬O ´²§G ªº ¹ê¨Ò, then there exist ¨ã»{ª¾¤O¬I¨ÆªÌ agent1,¨ã»{ª¾¤O¬I¨ÆªÌ agent2 so that disseminate (¤£) ²×µ²not(s) agent1 and disseminate (¤£) ²×µ²not(s) agent2 and agent1 µ¥©ó agent2.
(=>
      (instance ?DISSEMINATE Disseminating)
      (exists
            (?AGENT1 ?AGENT2)
            (and
                  (destination ?DISSEMINATE ?AGENT1)
                  (instance ?AGENT1 CognitiveAgent)
                  (destination ?DISSEMINATE ?AGENT2)
                  (instance ?AGENT2 CognitiveAgent)
                  (not
                        (equal ?AGENT1 ?AGENT2)))))

If advert ¬O ¼s§i ªº ¹ê¨Ò, then there exists obj so that advert °Ñ·Ó obj and advert ¦³ ·N¹Ï "there exists ¾P°â sale so that obj ¬O sale ªº ¨ü¨ÆªÌ".
(=>
      (instance ?ADVERT Advertising)
      (exists
            (?OBJ)
            (and
                  (refers ?ADVERT ?OBJ)
                  (hasPurpose
                        ?ADVERT
                        (exists
                              (?SALE)
                              (and
                                    (instance ?SALE Selling)
                                    (patient ?SALE ?OBJ)))))))

If communicate ¬O »y¨¥·¾³q ªº ¹ê¨Ò, then there exists »y¨¥ªí¦¡ obj so that obj ¬O communicate ªº ¨ü¨ÆªÌ.
(=>
      (instance ?COMMUNICATE LinguisticCommunication)
      (exists
            (?OBJ)
            (and
                  (instance ?OBJ LinguisticExpression)
                  (patient ?COMMUNICATE ?OBJ))))

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 order ¬O ©R¥O ªº ¹ê¨Ò and formula ¬O order ªº ¨ü¨ÆªÌ, then ³¯­z formula ¦³ ¸q°È ªº «¬ºA·N¸q.
(=>
      (and
            (instance ?ORDER Ordering)
            (patient ?ORDER ?FORMULA))
      (modalAttribute ?FORMULA Obligation))

If request ¬O ½Ð¨D ªº ¹ê¨Ò and request ¬O agent ªº ¬I¨ÆªÌ and formula ¬O request ªº ¨ü¨ÆªÌ and formula ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò, then agent (¤£) ¾¬¨Dnot(s) formula.
(=>
      (and
            (instance ?REQUEST Requesting)
            (agent ?REQUEST ?AGENT)
            (patient ?REQUEST ?FORMULA)
            (instance ?FORMULA Formula))
      (desires ?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 commit ¬O ©Ó¿Õ ªº ¹ê¨Ò and formula ¬O commit ªº ¨ü¨ÆªÌ and formula ¬O SUO-KIFªí­z¦¡ ªº ¹ê¨Ò, then ³¯­z formula ¦³ ©Ó¿Õ ªº «¬ºA·N¸q.
(=>
      (and
            (instance ?COMMIT Committing)
            (patient ?COMMIT ?FORMULA)
            (instance ?FORMULA Formula))
      (modalAttribute ?FORMULA Promise))

If express ¬O ªí¹F ªº ¹ê¨Ò and express ¬O agent ªº ¬I¨ÆªÌ, then there exists ¤ß²zª¬ºA state so that state ¬O agent ªº ÄÝ©Ê and express ªí¹F state.
(=>
      (and
            (instance ?EXPRESS Expressing)
            (agent ?EXPRESS ?AGENT))
      (exists
            (?STATE)
            (and
                  (instance ?STATE StateOfMind)
                  (attribute ?AGENT ?STATE)
                  (represents ?EXPRESS ?STATE))))

If declare ¬O «Å§i ªº ¹ê¨Ò and declare ¬O agent1 ªº ¬I¨ÆªÌ, then there exist proc,agent2 so that declare ½á¤© agent2 Åv¤O °õ¦æ Ãþ«¬ proc ¥ô°È or declare ½á¤© agent2 ¸q°È °õ¦æ Ãþ«¬ proc ¥ô°È.
(=>
      (and
            (instance ?DECLARE Declaring)
            (agent ?DECLARE ?AGENT1))
      (exists
            (?PROC ?AGENT2)
            (or
                  (confersRight ?PROC ?DECLARE ?AGENT2)
                  (confersObligation ?PROC ?DECLARE ?AGENT2))))

(=>
      (instance ?COOPERATE Cooperation)
      (exists
            (?PURP)
            (forall
                  (?AGENT)
                  (=>
                        (agent ?COOPERATE ?AGENT)
                        (hasPurposeForAgent ?COOPERATE ?PURP ?AGENT)))))

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 meet ¬O ·|­± ªº ¹ê¨Ò, then there exist agent1,agent2 so that meet ¬O agent1 ªº ¬I¨ÆªÌ and meet ¬O agent2 ªº ¬I¨ÆªÌ and meet ¦³ ·N¹Ï "there exists ·¾³q comm so that comm ¬O agent1 ªº ¬I¨ÆªÌ and comm ¬O agent2 ªº ¬I¨ÆªÌ".
(=>
      (instance ?MEET Meeting)
      (exists
            (?AGENT1 ?AGENT2)
            (and
                  (agent ?MEET ?AGENT1)
                  (agent ?MEET ?AGENT2)
                  (hasPurpose
                        ?MEET
                        (exists
                              (?COMM)
                              (and
                                    (instance ?COMM Communication)
                                    (agent ?COMM ?AGENT1)
                                    (agent ?COMM ?AGENT2)))))))

If contest ¬O Ävª§ ªº ¹ê¨Ò, then there exist agent1,agent2,purp1,purp2 so that contest ¬O agent1 ªº ¬I¨ÆªÌ and contest ¬O agent2 ªº ¬I¨ÆªÌ and contest ¹ïagent1 ¦³ ·N¹Ï purp1 and contest ¹ïagent2 ¦³ ·N¹Ï purp2 and agent1 µ¥©ó agent2 and purp1 µ¥©ó purp2.
(=>
      (instance ?CONTEST Contest)
      (exists
            (?AGENT1 ?AGENT2 ?PURP1 ?PURP2)
            (and
                  (agent ?CONTEST ?AGENT1)
                  (agent ?CONTEST ?AGENT2)
                  (hasPurposeForAgent ?CONTEST ?PURP1 ?AGENT1)
                  (hasPurposeForAgent ?CONTEST ?PURP2 ?AGENT2)
                  (not
                        (equal ?AGENT1 ?AGENT2))
                  (not
                        (equal ?PURP1 ?PURP2)))))

If war ¬O ¾Ôª§ ªº ¹ê¨Ò, then there exists ¾Ô§Ð battle so that battle ¬O war ªº ¦¸¾úµ{.
(=>
      (instance ?WAR War)
      (exists
            (?BATTLE)
            (and
                  (instance ?BATTLE Battle)
                  (subProcess ?BATTLE ?WAR))))

(=>
      (and
            (instance ?WAR War)
            (agent ?WAR ?AGENT))
      (or
            (instance ?AGENT Nation)
            (and
                  (instance ?AGENT Organization)
                  (forall
                        (?MEMBER)
                        (=>
                              (member ?MEMBER ?AGENT)
                              (instance ?MEMBER Nation))))))

If battle ¬O ¾Ô§Ð ªº ¹ê¨Ò, then there exists ¾Ôª§ war so that battle ¬O war ªº ¦¸¾úµ{.
(=>
      (instance ?BATTLE Battle)
      (exists
            (?WAR)
            (and
                  (instance ?WAR War)
                  (subProcess ?BATTLE ?WAR))))

If battle ¬O ¾Ô§Ð ªº ¹ê¨Ò, then there exists ¼É¤O©ÊªºÄvª§ attack so that attack ¬O battle ªº ¦¸¾úµ{.
(=>
      (instance ?BATTLE Battle)
      (exists
            (?ATTACK)
            (and
                  (instance ?ATTACK ViolentContest)
                  (subProcess ?ATTACK ?BATTLE))))

If move ¬O ½Õ»º ªº ¹ê¨Ò, then there exists Ävª§ contest so that move ¬O contest ªº ¦¸¾úµ{.
(=>
      (instance ?MOVE Maneuver)
      (exists
            (?CONTEST)
            (and
                  (instance ?CONTEST Contest)
                  (subProcess ?MOVE ?CONTEST))))

If percept ¬O ª¾Ä± ªº ¹ê¨Ò and percept ¬O agent ªº ¬I¨ÆªÌ, then agent ¬O °Êª« ªº ¹ê¨Ò.
(=>
      (and
            (instance ?PERCEPT Perception)
            (agent ?PERCEPT ?AGENT))
      (instance ?AGENT Animal))

If percept ¬O ª¾Ä± ªº ¹ê¨Ò and percept ¬O agent ªº ¬I¨ÆªÌ and object ¬O percept ªº ¨ü¨ÆªÌ, then agent (¨S) ª`·N¨ìnot(s) object.
(=>
      (and
            (instance ?PERCEPT Perception)
            (agent ?PERCEPT ?AGENT)
            (patient ?PERCEPT ?OBJECT))
      (notices ?AGENT ?OBJECT))

If agent ¬O ¯àª¾Ä±ªº¦æ¬°¥DÅé ªº ¹ê¨Ò, then agent ¥i¥H ¥ô¨¤¦â ¸gÅçªÌ °µ ª¾Ä±.
(=>
      (instance ?AGENT SentientAgent)
      (capability Perception experiencer ?AGENT))

If see ¬O ¬Ý ªº ¹ê¨Ò and see ¬O agent ªº ¬I¨ÆªÌ and obj ¬O see ªº ¨ü¨ÆªÌ, then
(=>
      (and
            (instance ?SEE Seeing)
            (agent ?SEE ?AGENT)
            (patient ?SEE ?OBJ))
      (and
            (attribute ?OBJ Illuminated)
            (exists
                  (?PROP)
                  (and
                        (instance ?PROP ColorAttribute)
                        (knows
                              ?AGENT
                              (attribute ?OBJ ?PROP))))))

If smell ¬O »D ªº ¹ê¨Ò and obj ¬O smell ªº ¨ü¨ÆªÌ, then there exists ¶åıÄÝ©Ê attr so that attr ¬O obj ªº ÄÝ©Ê.
(=>
      (and
            (instance ?SMELL Smelling)
            (patient ?SMELL ?OBJ))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR OlfactoryAttribute)
                  (attribute ?OBJ ?ATTR))))

If taste ¬O ¨ýı ªº ¹ê¨Ò and obj ¬O taste ªº ¨ü¨ÆªÌ, then there exists ¨ýıÄÝ©Ê attr so that attr ¬O obj ªº ÄÝ©Ê.
(=>
      (and
            (instance ?TASTE Tasting)
            (patient ?TASTE ?OBJ))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR TasteAttribute)
                  (attribute ?OBJ ?ATTR))))

If hear ¬O Å¥ ªº ¹ê¨Ò and obj ¬O hear ªº ¨ü¨ÆªÌ, then there exists Án­µÄÝ©Ê attr so that attr ¬O obj ªº ÄÝ©Ê.
(=>
      (and
            (instance ?HEAR Hearing)
            (patient ?HEAR ?OBJ))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR SoundAttribute)
                  (attribute ?OBJ ?ATTR))))

If tactile ¬O IJı ªº ¹ê¨Ò, then there exists IJ°Ê touch so that touch ¬O tactile ªº ¦¸¾úµ{.
(=>
      (instance ?TACTILE TactilePerception)
      (exists
            (?TOUCH)
            (and
                  (instance ?TOUCH Touching)
                  (subProcess ?TOUCH ?TACTILE))))

If emit ¬O Án­µ ªº ¹ê¨Ò and emit ¬O sound ªº ¬I¨ÆªÌ, then there exists Án­µÄÝ©Ê attr so that attr ¬O sound ªº ÄÝ©Ê.
(=>
      (and
            (instance ?EMIT RadiatingSound)
            (agent ?EMIT ?SOUND))
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR SoundAttribute)
                  (attribute ?SOUND ?ATTR))))

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 º²¤Æ ªº ¹ê¨Ò, then there exists ¥[·Å heat so that heat ¬O melt ªº ¦¸¾úµ{.
(=>
      (instance ?MELT Melting)
      (exists
            (?HEAT)
            (and
                  (instance ?HEAT Heating)
                  (subProcess ?HEAT ?MELT))))

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ÄË ªº ¹ê¨Ò, then there exists ¥[·Å heat so that heat ¬O boil ªº ¦¸¾úµ{.
(=>
      (instance ?BOIL Boiling)
      (exists
            (?HEAT)
            (and
                  (instance ?HEAT Heating)
                  (subProcess ?HEAT ?BOIL))))

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 ¾®µ² ªº ¹ê¨Ò, then there exists ­°·Å cool so that cool ¬O cond ªº ¦¸¾úµ{.
(=>
      (instance ?COND Condensing)
      (exists
            (?COOL)
            (and
                  (instance ?COOL Cooling)
                  (subProcess ?COOL ?COND))))

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 ªº ¹ê¨Ò, then there exists ­°·Å cool so that cool ¬O freeze ªº ¦¸¾úµ{.
(=>
      (instance ?FREEZE Freezing)
      (exists
            (?COOL)
            (and
                  (instance ?COOL Cooling)
                  (subProcess ?COOL ?FREEZE))))

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 area ¬O ¤ô°ì ªº ¹ê¨Ò, then there exist bed,hole,¤ô water so that "¬} hole ªº ¥DÅé" µ¥©ó bed and water (¨S) ¾A·í¶ñ¥Rs hole and "bed ©M water ªº Áp¶°" µ¥©ó area.
(=>
      (instance ?AREA WaterArea)
      (exists
            (?BED ?HOLE ?WATER)
            (and
                  (equal
                        (PrincipalHostFn ?HOLE)
                        ?BED)
                  (instance ?WATER Water)
                  (properlyFills ?WATER ?HOLE)
                  (equal
                        (MereologicalSumFn ?BED ?WATER)
                        ?AREA))))

If land1 ¬O ³°¦a ªº ¹ê¨Ò, then there exists land2 so that land1 ¬O land2 ªº ³¡¤À) and land2 ¬O ¤j³° ªº ¹ê¨Ò or land2 ¬O ®qÀ¬ ªº ¹ê¨Ò.
(=>
      (instance ?LAND1 LandArea)
      (exists
            (?LAND2)
            (and
                  (part ?LAND1 ?LAND2)
                  (or
                        (instance ?LAND2 Continent)
                        (instance ?LAND2 Island)))))

If island ¬O ®qÀ¬ ªº ¹ê¨Ò, then there don't exist ³°¦a area,part1,part2 so that part1 ¬O island ªº ³¡¤À) and part2 ¬O area ªº ³¡¤À) and island ¬O area ªº ³¡¤À) and area ¬O island ªº ³¡¤À) and part1 »P part2 ¬Û³s.
(=>
      (instance ?ISLAND Island)
      (not
            (exists
                  (?AREA ?PART1 ?PART2)
                  (and
                        (instance ?AREA LandArea)
                        (part ?PART1 ?ISLAND)
                        (part ?PART2 ?AREA)
                        (not
                              (part ?ISLAND ?AREA))
                        (not
                              (part ?AREA ?ISLAND))
                        (connected ?PART1 ?PART2)))))

If state ¬O ¦{©Î¬Ù ªº ¹ê¨Ò, then there exists °ê®a land so that state ¬O land ªº ¥¿³¡¤À.
(=>
      (instance ?STATE StateOrProvince)
      (exists
            (?LAND)
            (and
                  (instance ?LAND Nation)
                  (properPart ?STATE ?LAND))))

If obj ªº µo®i§Î¦¡ ¬O attr1 time1a(¤§¤¤) time1 and attr2 ¬O attr1 ªº «Ê³¬Äò±µÄÝ©Ê, then there exists time2 so that time2 (¨S) ¤ñ time1 ¸û¦­ µo¥Ínot(s) and obj ªº µo®i§Î¦¡ ¬O attr2 time2a(¤§¤¤) time2.
(=>
      (and
            (holdsDuring
                  ?TIME1
                  (developmentalForm ?OBJ ?ATTR1))
            (successorAttributeClosure ?ATTR2 ?ATTR1))
      (exists
            (?TIME2)
            (and
                  (earlier ?TIME2 ?TIME1)
                  (holdsDuring
                        ?TIME2
                        (developmentalForm ?OBJ ?ATTR2)))))

If organism ¬O ¥Íª«Åé ªº ¹ê¨Ò, then there exists ½Ï¥Í birth so that organism (¨S) ÅéÅçnot(s) birth.
(=>
      (instance ?ORGANISM Organism)
      (exists
            (?BIRTH)
            (and
                  (instance ?BIRTH Birth)
                  (experiencer ?BIRTH ?ORGANISM))))

If organism ¦ís ¦b obj, then there exists time so that organism ¦ì©ó obj timea(¤§¤¤) time.
(=>
      (inhabits ?ORGANISM ?OBJ)
      (exists
            (?TIME)
            (holdsDuring
                  ?TIME
                  (located ?ORGANISM ?OBJ))))

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))))

If parent ¬O child ªº Âù¿Ë and class ¬O ¥Íª«Åé ªº ¦¸ºØÃþ and parent ¬O class ªº ¹ê¨Ò, then child ¬O class ªº ¹ê¨Ò.
(=>
      (and
            (parent ?CHILD ?PARENT)
            (subclass ?CLASS Organism)
            (instance ?PARENT ?CLASS))
      (instance ?CHILD ?CLASS))

If parent ¬O child ªº Âù¿Ë, then parent ¬O child ªº ¥À¿Ë or parent ¬O child ªº ¤÷¿Ë.
(=>
      (parent ?CHILD ?PARENT)
      (or
            (mother ?CHILD ?PARENT)
            (father ?CHILD ?PARENT)))

If organism ¬O ¥Íª«Åé ªº ¹ê¨Ò, then there exists parent so that parent ¬O organism ªº Âù¿Ë.
(=>
      (instance ?ORGANISM Organism)
      (exists
            (?PARENT)
            (parent ?ORGANISM ?PARENT)))

If mother ¬O child ªº ¥À¿Ë, then »Û©Ê ¬O mother ªº ÄÝ©Ê.
(=>
      (mother ?CHILD ?MOTHER)
      (attribute ?MOTHER Female))

If father ¬O child ªº ¤÷¿Ë, then ¶¯©Ê ¬O father ªº ÄÝ©Ê.
(=>
      (father ?CHILD ?FATHER)
      (attribute ?FATHER Male))

If alga ¬O ĦÃþ ªº ¹ê¨Ò, then there exists ¤ô water so that alga ¦ís ¦b water.
(=>
      (instance ?ALGA Alga)
      (exists
            (?WATER)
            (and
                  (inhabits ?ALGA ?WATER)
                  (instance ?WATER Water))))

If fungus ¬O ¯uµß ªº ¹ê¨Ò and fungus ¦ís ¦b obj, then obj ¬O ¥Íª«Åé ªº ¹ê¨Ò.
(=>
      (and
            (instance ?FUNGUS Fungus)
            (inhabits ?FUNGUS ?OBJ))
      (instance ?OBJ Organism))

(=>
      (instance ?BACTERIUM Bacterium)
      (exists
            (?CELL1)
            (and
                  (component ?CELL1 ?BACTERIUM)
                  (instance ?CELL1 Cell)
                  (forall
                        (?CELL2)
                        (=>
                              (and
                                    (component ?CELL2 ?BACTERIUM)
                                    (instance ?CELL2 Cell))
                              (equal ?CELL1 ?CELL2))))))

If bacterium ¬O ²Óµß ªº ¹ê¨Ò and bacterium ¦ís ¦b obj, then obj ¬O ¥Íª«Åé ªº ¹ê¨Ò.
(=>
      (and
            (instance ?BACTERIUM Bacterium)
            (inhabits ?BACTERIUM ?OBJ))
      (instance ?OBJ Organism))

(=>
      (instance ?VIRUS Virus)
      (exists
            (?MOL1)
            (and
                  (component ?MOL1 ?VIRUS)
                  (instance ?MOL1 Molecule)
                  (forall
                        (?MOL2)
                        (=>
                              (and
                                    (component ?MOL2 ?VIRUS)
                                    (instance ?MOL2 Molecule))
                              (equal ?MOL1 ?MOL2))))))

If virus ¬O ¯f¬r ªº ¹ê¨Ò and virus ¦ís ¦b obj, then obj ¬O ¥Íª«Åé ªº ¹ê¨Ò.
(=>
      (and
            (instance ?VIRUS Virus)
            (inhabits ?VIRUS ?OBJ))
      (instance ?OBJ Organism))

If virus ¬O ¯f¬r ªº ¹ê¨Ò and proc ¬O ½Æ»s ªº ¹ê¨Ò and proc ¬O virus ªº ¬I¨ÆªÌ, then there exists ²Ó­M cell so that proc ¦ì©ó cell.
(=>
      (and
            (instance ?VIRUS Virus)
            (instance ?PROC Replication)
            (agent ?PROC ?VIRUS))
      (exists
            (?CELL)
            (and
                  (located ?PROC ?CELL)
                  (instance ?CELL Cell))))

If fish ¬O ³½Ãþ ªº ¹ê¨Ò, then there exists ¤ô water so that fish ¦ís ¦b water.
(=>
      (instance ?FISH Fish)
      (exists
            (?WATER)
            (and
                  (inhabits ?FISH ?WATER)
                  (instance ?WATER Water))))

If organism ¬O ¬r©Ê¥Íª« ªº ¹ê¨Ò, then there exists ¬¡©Ê¥Íª«ª«½è substance so that substance ¬O organism ªº ³¡¤À).
(=>
      (instance ?ORGANISM ToxicOrganism)
      (exists
            (?SUBSTANCE)
            (and
                  (instance ?SUBSTANCE BiologicallyActiveSubstance)
                  (part ?SUBSTANCE ?ORGANISM))))

If food ¬O ­¹ª« ªº ¹ê¨Ò, then there exists ¾i¥÷ nutrient so that nutrient ¬O food ªº ³¡¤À).
(=>
      (instance ?FOOD Food)
      (exists
            (?NUTRIENT)
            (and
                  (instance ?NUTRIENT Nutrient)
                  (part ?NUTRIENT ?FOOD))))

(=>
      (instance ?FOOD Food)
      (forall
            (?PART1)
            (=>
                  (part ?PART1 ?FOOD)
                  (exists
                        (?PART2 ?ANIMAL)
                        (and
                              (part ?PART1 ?PART2)
                              (part ?PART2 ?ANIMAL)
                              (instance ?ANIMAL Animal))))))

(=>
      (instance ?MEAT Meat)
      (forall
            (?PART)
            (=>
                  (part ?PART ?MEAT)
                  (exists
                        (?SUBPART ?TIME ?ANIMAL)
                        (and
                              (part ?SUBPART ?PART)
                              (holdsDuring
                                    ?TIME
                                    (and
                                          (instance ?ANIMAL Animal)
                                          (part ?SUBPART ?ANIMAL))))))))

(=>
      (instance ?VEG FruitOrVegetable)
      (forall
            (?PART)
            (=>
                  (part ?PART ?VEG)
                  (exists
                        (?SUBPART ?TIME ?PLANT)
                        (and
                              (part ?SUBPART ?PART)
                              (holdsDuring
                                    ?TIME
                                    (and
                                          (instance ?PLANT Plant)
                                          (part ?SUBPART ?PLANT))))))))

If bev ¬O ¶¼®Æ ªº ¹ê¨Ò, then ²GÅ骺 ¬O bev ªº ÄÝ©Ê.
(=>
      (instance ?BEV Beverage)
      (attribute ?BEV Liquid))

If drink ¬O ³Ü ªº ¹ê¨Ò and bev ¬O drink ªº ¨ü¨ÆªÌ, then bev ¬O ¶¼®Æ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?DRINK Drinking)
            (patient ?DRINK ?BEV))
      (instance ?BEV Beverage))

If anat ¬O ¸Ñ­åºc³y ªº ¹ê¨Ò, then there exists ¥Íª«Åé organism so that anat ¬O organism ªº ³¡¤À).
(=>
      (instance ?ANAT AnatomicalStructure)
      (exists
            (?ORGANISM)
            (and
                  (instance ?ORGANISM Organism)
                  (part ?ANAT ?ORGANISM))))

If part ¬O ¸Ñ­åºc³y ªº ¹ê¨Ò, then there exists ²Ó­M cell so that cell ¬O part ªº ³¡¤À).
(=>
      (instance ?PART AnatomicalStructure)
      (exists
            (?CELL)
            (and
                  (instance ?CELL Cell)
                  (part ?CELL ?PART))))

If part ¬O ÂßÅ鳡¥ó ªº ¹ê¨Ò, then there doesn't exist ¯f²z¾úµ{ proc so that part ¬O proc ªº µ²ªG.
(=>
      (instance ?PART BodyPart)
      (not
            (exists
                  (?PROC)
                  (and
                        (instance ?PROC PathologicProcess)
                        (result ?PROC ?PART)))))

If cover ¬O ÂßÅéªí­±¡]Âл\ª«¡^ ªº ¹ê¨Ò, then there exists body so that cover ¬O bodyªº ¥~ªí³¡¤À and body ¬O ¥Íª«Åé ªº ¹ê¨Ò or body ¬O ÂßÅ鳡¥ó ªº ¹ê¨Ò.
(=>
      (instance ?COVER BodyCovering)
      (exists
            (?BODY)
            (and
                  (superficialPart ?COVER ?BODY)
                  (or
                        (instance ?BODY Organism)
                        (instance ?BODY BodyPart)))))

If junct ¬O ÂßÅé±µÂI ªº ¹ê¨Ò, then there exists ÂßÅ鳡¥ó struct so that junct ¬O struct ªº ¤¸¥ó.
(=>
      (instance ?JUNCT BodyJunction)
      (exists
            (?STRUCT)
            (and
                  (instance ?STRUCT BodyPart)
                  (component ?JUNCT ?STRUCT))))

If junct ¬O ÂßÅé±µÂI ªº ¹ê¨Ò, then there exist ÂßÅ鳡¥ó struct1,ÂßÅ鳡¥ó struct2 so that junct »P struct1 ¬Û³s and junct »P struct2 ¬Û³s and struct1 µ¥©ó struct2.
(=>
      (instance ?JUNCT BodyJunction)
      (exists
            (?STRUCT1 ?STRUCT2)
            (and
                  (connected ?JUNCT ?STRUCT1)
                  (connected ?JUNCT ?STRUCT2)
                  (instance ?STRUCT1 BodyPart)
                  (instance ?STRUCT2 BodyPart)
                  (not
                        (equal ?STRUCT1 ?STRUCT2)))))

If organ ¬O ¾¹©x ªº ¹ê¨Ò, then there exists purp so that organ ¦³ ·N¹Ï purp.
(=>
      (instance ?ORGAN Organ)
      (exists
            (?PURP)
            (hasPurpose ?ORGAN ?PURP)))

If stuff ¬O ²Õ´ ªº ¹ê¨Ò, then there exists ²Ó­M part so that part ¬O stuff ªº ³¡¤À).
(=>
      (instance ?STUFF Tissue)
      (exists
            (?PART)
            (and
                  (instance ?PART Cell)
                  (part ?PART ?STUFF))))

If stuff ¬O ²Õ´ ªº ¹ê¨Ò, then there exists ¥Íª«Åé organism so that stuff ¬O organism ªº ³¡¤À).
(=>
      (instance ?STUFF Tissue)
      (exists
            (?ORGANISM)
            (and
                  (instance ?ORGANISM Organism)
                  (part ?STUFF ?ORGANISM))))

If bone ¬O °©Àf ªº ¹ê¨Ò, then there exists ¯á´Õ°Êª« vert so that bone ¬O vert ªº ³¡¤À).
(=>
      (instance ?BONE Bone)
      (exists
            (?VERT)
            (and
                  (instance ?VERT Vertebrate)
                  (part ?BONE ?VERT))))

If morph ¬O µü¯À ªº ¹ê¨Ò, then there doesn't exist µü¯À othermorph so that othermorph ¬O morph ªº ³¡¤À) and othermorph µ¥©ó morph.
(=>
      (instance ?MORPH Morpheme)
      (not
            (exists
                  (?OTHERMORPH)
                  (and
                        (instance ?OTHERMORPH Morpheme)
                        (part ?OTHERMORPH ?MORPH)
                        (not
                              (equal ?OTHERMORPH ?MORPH))))))

If morph ¬O µü¯À ªº ¹ê¨Ò, then there exists µü word so that morph ¬O word ªº ³¡¤À).
(=>
      (instance ?MORPH Morpheme)
      (exists
            (?WORD)
            (and
                  (instance ?WORD Word)
                  (part ?MORPH ?WORD))))

If word ¬O µü ªº ¹ê¨Ò, then there exists µü¯À part so that part ¬O word ªº ³¡¤À).
(=>
      (instance ?WORD Word)
      (exists
            (?PART)
            (and
                  (part ?PART ?WORD)
                  (instance ?PART Morpheme))))

If phrase ¬O µü²Õ ªº ¹ê¨Ò, then there exist µü part1,µü part2 so that part1 ¬O phrase ªº ³¡¤À) and part2 ¬O phrase ªº ³¡¤À) and part1 µ¥©ó part2.
(=>
      (instance ?PHRASE Phrase)
      (exists
            (?PART1 ?PART2)
            (and
                  (part ?PART1 ?PHRASE)
                  (part ?PART2 ?PHRASE)
                  (instance ?PART1 Word)
                  (instance ?PART2 Word)
                  (not
                        (equal ?PART1 ?PART2)))))

If sentence ¬O ¥y¤l ªº ¹ê¨Ò, then there exist ¦Wµüµü²Õ phrase1,°Êµüµü²Õ phrase2 so that phrase1 ¬O sentence ªº ³¡¤À) and phrase2 ¬O sentence ªº ³¡¤À).
(=>
      (instance ?SENTENCE Sentence)
      (exists
            (?PHRASE1 ?PHRASE2)
            (and
                  (instance ?PHRASE1 NounPhrase)
                  (instance ?PHRASE2 VerbPhrase)
                  (part ?PHRASE1 ?SENTENCE)
                  (part ?PHRASE2 ?SENTENCE))))

If text ¬O ¤å¥» ªº ¹ê¨Ò, then there exists ©RÃD prop so that text (¤£) ¥]§ts) °T®§ %2.
(=>
      (instance ?TEXT Text)
      (exists
            (?PROP)
            (and
                  (instance ?PROP Proposition)
                  (containsInformation ?TEXT ?PROP))))

If text ¬O ¤å¥» ªº ¹ê¨Ò, then there exists ¥y¤l part so that part ¬O text ªº ³¡¤À).
(=>
      (instance ?TEXT Text)
      (exists
            (?PART)
            (and
                  (part ?PART ?TEXT)
                  (instance ?PART Sentence))))

If text ¬O ¤å¥» ªº ¹ê¨Ò, then there exists ¼g§@ write so that text ¬O write ªº µ²ªG.
(=>
      (instance ?TEXT Text)
      (exists
            (?WRITE)
            (and
                  (instance ?WRITE Writing)
                  (result ?WRITE ?TEXT))))

If sent ¬O ¥y¤l ªº ¹ê¨Ò, then there exist ¦Wµüµü²Õ noun,°Êµüµü²Õ verb so that noun ¬O sent ªº ³¡¤À) and verb ¬O sent ªº ³¡¤À).
(=>
      (instance ?SENT Sentence)
      (exists
            (?NOUN ?VERB)
            (and
                  (instance ?NOUN NounPhrase)
                  (instance ?VERB VerbPhrase)
                  (part ?NOUN ?SENT)
                  (part ?VERB ?SENT))))

If §@ªÌ(agent,text) holds, then there exist process,text instance so that process ¬O agent ªº ¬I¨ÆªÌ and text ¬O process ªº µ²ªG.
(=>
      (authors ?AGENT ?TEXT)
      (exists
            (?PROCESS ?INSTANCE)
            (and
                  (agent ?PROCESS ?AGENT)
                  (instance ?INSTANCE ?TEXT)
                  (result ?PROCESS ?TEXT))))

If "text ªº ª©¥» int1 " µ¥©ó edition1 and "text ªº ª©¥» int2 " µ¥©ó edition2 and int2 (¤£) ¤j©ó int1 and pub1 ¬O ¥Xª© ªº ¹ê¨Ò and pub2 ¬O ¥Xª© ªº ¹ê¨Ò and edition1 ¬O pub1 ªº ¨ü¨ÆªÌ and edition2 ¬O pub2 ªº ¨ü¨ÆªÌ and pub1 ªº ¤é´Á ¬O date1 and pub2 ªº ¤é´Á ¬O date2, then "date1 ªº µ²§ô" (¨S) µo¥Í?{s} ¦b "date2 ªº µ²§ô" ¤§«e.
(=>
      (and
            (equal
                  (EditionFn ?TEXT ?INT1)
                  ?EDITION1)
            (equal
                  (EditionFn ?TEXT ?INT2)
                  ?EDITION2)
            (greaterThan ?INT2 ?INT1)
            (instance ?PUB1 Publication)
            (instance ?PUB2 Publication)
            (patient ?PUB1 ?EDITION1)
            (patient ?PUB2 ?EDITION2)
            (date ?PUB1 ?DATE1)
            (date ?PUB2 ?DATE2))
      (before
            (EndFn ?DATE1)
            (EndFn ?DATE2)))

If "text1 ªº ª©¥» number " µ¥©ó text2, then text1 ¥]®e text2.
(=>
      (equal
            (EditionFn ?TEXT1 ?NUMBER)
            ?TEXT2)
      (subsumesContentClass ?TEXT1 ?TEXT2))

If text ¬O ´Á¥Z ªº ¦¸ºØÃþ and "¥U int1 ¦b ¨t¦C¼Æ text" µ¥©ó volume1 and "¥U int2 ¦b ¨t¦C¼Æ text" µ¥©ó volume2 and int2 (¤£) ¤j©ó int1 and pub1 ¬O ¥Xª© ªº ¹ê¨Ò and pub2 ¬O ¥Xª© ªº ¹ê¨Ò and volume1 ¬O pub1 ªº ¨ü¨ÆªÌ and volume2 ¬O pub2 ªº ¨ü¨ÆªÌ and pub1 ªº ¤é´Á ¬O date1 and pub2 ªº ¤é´Á ¬O date2, then "date1 ªº µ²§ô" (¨S) µo¥Í?{s} ¦b "date2 ªº µ²§ô" ¤§«e.
(=>
      (and
            (subclass ?TEXT Periodical)
            (equal
                  (SeriesVolumeFn ?TEXT ?INT1)
                  ?VOLUME1)
            (equal
                  (SeriesVolumeFn ?TEXT ?INT2)
                  ?VOLUME2)
            (greaterThan ?INT2 ?INT1)
            (instance ?PUB1 Publication)
            (instance ?PUB2 Publication)
            (patient ?PUB1 ?VOLUME1)
            (patient ?PUB2 ?VOLUME2)
            (date ?PUB1 ?DATE1)
            (date ?PUB2 ?DATE2))
      (before
            (EndFn ?DATE1)
            (EndFn ?DATE2)))

If "¥U number ¦b ¨t¦C¼Æ series" µ¥©ó volume, then series ¥]®e volume.
(=>
      (equal
            (SeriesVolumeFn ?SERIES ?NUMBER)
            ?VOLUME)
      (subsumesContentClass ?SERIES ?VOLUME))

If "periodical ªº ´Á¥Z¼Æ number" µ¥©ó issue, then periodical ¥]®e issue.
(=>
      (equal
            (PeriodicalIssueFn ?PERIODICAL ?NUMBER)
            ?ISSUE)
      (subsumesContentClass ?PERIODICAL ?ISSUE))

If text ¬O ºK­n ªº ¹ê¨Ò, then there exists ¤å¥» text2 so that text2 ¥]®e text.
(=>
      (instance ?TEXT Summary)
      (exists
            (?TEXT2)
            (and
                  (instance ?TEXT2 Text)
                  (subsumesContentInstance ?TEXT2 ?TEXT))))

If series ¬O ¨t¦C¥Zª« ªº ¹ê¨Ò, then there exist ®ÑÄy book1,®ÑÄy book2 so that series ¥]®e book1 and series ¥]®e book2 and book1 µ¥©ó book2.
(=>
      (instance ?SERIES Series)
      (exists
            (?BOOK1 ?BOOK2)
            (and
                  (instance ?BOOK1 Book)
                  (instance ?BOOK2 Book)
                  (subsumesContentInstance ?SERIES ?BOOK1)
                  (subsumesContentInstance ?SERIES ?BOOK2)
                  (not
                        (equal ?BOOK1 ?BOOK2)))))

If article ¬O ¤å³¹ ªº ¹ê¨Ò, then there exists ®ÑÄy book so that book ¥]®e article.
(=>
      (instance ?ARTICLE Article)
      (exists
            (?BOOK)
            (and
                  (instance ?BOOK Book)
                  (subsumesContentInstance ?BOOK ?ARTICLE))))

If doc ¬O ÃÒ®Ñ ªº ¹ê¨Ò and agent (¨S) ¾Ö¦³not(s) doc, then there exists proc so that doc ½á¤© agent Åv¤O °õ¦æ Ãþ«¬ proc ¥ô°È or doc ½á¤© agent ¸q°È °õ¦æ Ãþ«¬ proc ¥ô°È.
(=>
      (and
            (instance ?DOC Certificate)
            (possesses ?AGENT ?DOC))
      (exists
            (?PROC)
            (or
                  (confersRight ?PROC ?DOC ?AGENT)
                  (confersObligation ?PROC ?DOC ?AGENT))))

If mole ¬O ¤À¤l ªº ¹ê¨Ò, then there exist ­ì¤l atom1,­ì¤l atom2 so that atom1 ¬O mole ªº ³¡¤À) and atom2 ¬O mole ªº ³¡¤À) and atom1 µ¥©ó atom2.
(=>
      (instance ?MOLE Molecule)
      (exists
            (?ATOM1 ?ATOM2)
            (and
                  (instance ?ATOM1 Atom)
                  (instance ?ATOM2 Atom)
                  (part ?ATOM1 ?MOLE)
                  (part ?ATOM2 ?MOLE)
                  (not
                        (equal ?ATOM1 ?ATOM2)))))

If product ¬O ²£«~ ªº ¹ê¨Ò, then there exists ¥Í²£ manufacture so that product ¬O manufacture ªº µ²ªG.
(=>
      (instance ?PRODUCT Product)
      (exists
            (?MANUFACTURE)
            (and
                  (instance ?MANUFACTURE Manufacture)
                  (result ?MANUFACTURE ?PRODUCT))))

If artifact1 ¬O artifact2 ªº ª©¥», then artifact1 ¬O artifact2 ªº ¦¸ºØÃþ.
(=>
      (version ?ARTIFACT1 ?ARTIFACT2)
      (subclass ?ARTIFACT1 ?ARTIFACT2))

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

If building ¬O «Ø¿vª« ªº ¹ê¨Ò, then there exists ¤HÃþ human so that
(=>
      (instance ?BUILDING Building)
      (exists
            (?HUMAN)
            (and
                  (instance ?HUMAN Human)
                  (or
                        (inhabits ?HUMAN ?BUILDING)
                        (exists
                              (?ACT)
                              (and
                                    (agent ?ACT ?HUMAN)
                                    (located ?ACT ?BUILDING)))))))

If room ¬O ©Ð¶¡ ªº ¹ê¨Ò, then there exists «Ø¿vª« build so that room ¬O build ªº ¥¿³¡¤À.
(=>
      (instance ?ROOM Room)
      (exists
            (?BUILD)
            (and
                  (instance ?BUILD Building)
                  (properPart ?ROOM ?BUILD))))

If clothing ¬O ¦çª« ªº ¹ê¨Ò, then there exists ´ª« fabric so that fabric ¬O clothing ªº ³¡¤À).
(=>
      (instance ?CLOTHING Clothing)
      (exists
            (?FABRIC)
            (and
                  (instance ?FABRIC Fabric)
                  (part ?FABRIC ?CLOTHING))))

If device ¬O ¸Ë¸m ªº ¹ê¨Ò, then there exists ¾úµ{ proc so that device ¥i¥H ¥ô¨¤¦â ¤u¨ã °µ proc.
(=>
      (instance ?DEVICE Device)
      (exists
            (?PROC)
            (and
                  (subclass ?PROC Process)
                  (capability ?PROC instrument ?DEVICE))))

If device ¬O ¸Ë¸m ªº ¹ê¨Ò, then there exists ¾úµ{ proc so that device ¦³ ·N¹Ï "device ¥i¥H ¥ô¨¤¦â ¤u¨ã °µ proc".
(=>
      (instance ?DEVICE Device)
      (exists
            (?PROC)
            (and
                  (subclass ?PROC Process)
                  (hasPurpose
                        ?DEVICE
                        (capability ?PROC instrument ?DEVICE)))))

If instrument ¬O ¼Ö¾¹ ªº ¹ê¨Ò, then instrument ¥i¥H ¥ô¨¤¦â ¤u¨ã °µ ­µ¼Ö.
(=>
      (instance ?INSTRUMENT MusicalInstrument)
      (capability Music instrument ?INSTRUMENT))

If device ¬O ¹B¿é¤u¨ã ªº ¹ê¨Ò, then device ¥i¥H ¥ô¨¤¦â ¤u¨ã °µ ¹B¿é.
(=>
      (instance ?DEVICE TransportationDevice)
      (capability Transportation instrument ?DEVICE))

If weapon ¬O ªZ¾¹ ªº ¹ê¨Ò, then weapon ¥i¥H ¥ô¨¤¦â ¤u¨ã °µ ·l®`.
(=>
      (instance ?WEAPON Weapon)
      (capability Damaging instrument ?WEAPON))

If weapon ¬O ªZ¾¹ ªº ¹ê¨Ò, then weapon ¦³ ·N¹Ï "there exist ·l®` dest,patient so that patient ¬O dest ªº ¨ü¨ÆªÌ and ".
(=>
      (instance ?WEAPON Weapon)
      (hasPurpose
            ?WEAPON
            (exists
                  (?DEST ?PATIENT)
                  (and
                        (instance ?DEST Damaging)
                        (patient ?DEST ?PATIENT)
                        (or
                              (instance ?PATIENT StationaryArtifact)
                              (instance ?PATIENT Animal)
                              (exists
                                    (?ANIMAL)
                                    (and
                                          (instance ?ANIMAL Animal)
                                          (inhabits ?ANIMAL ?PATIENT))))))))

(=>
      (instance ?MACHINE Machine)
      (forall
            (?PROC)
            (=>
                  (instrument ?PROC ?MACHINE)
                  (exists
                        (?RESOURCE ?RESULT)
                        (and
                              (resource ?PROC ?RESOURCE)
                              (result ?PROC ?RESULT))))))

If comp ¬O ¤uµ{¤¸¥ó ªº ¹ê¨Ò, then there exists ¸Ë¸m device so that comp ¬O device ªº ¤¸¥ó.
(=>
      (instance ?COMP EngineeringComponent)
      (exists
            (?DEVICE)
            (and
                  (instance ?DEVICE Device)
                  (component ?COMP ?DEVICE))))

If comp1 »P comp2 ³sµ², then comp1 ¬O comp2 ªº ¤¸¥ó and comp2 ¬O comp1 ªº ¤¸¥ó.
(=>
      (connectedEngineeringComponents ?COMP1 ?COMP2)
      (and
            (not
                  (engineeringSubcomponent ?COMP1 ?COMP2))
            (not
                  (engineeringSubcomponent ?COMP2 ?COMP1))))

If comp1 »P comp2 ³sµ², then comp1 ¬O ¤uµ{³sµ²¤¸¥ó ªº ¹ê¨Ò and comp2 ¬O ¤uµ{³sµ²¤¸¥ó ªº ¹ê¨Ò.
(=>
      (connectedEngineeringComponents ?COMP1 ?COMP2)
      (not
            (or
                  (instance ?COMP1 EngineeringConnection)
                  (instance ?COMP2 EngineeringConnection))))

If connection ¬O ¤uµ{³sµ²¤¸¥ó ªº ¹ê¨Ò, then there exist comp1,comp2 so that connection ³sµ² comp1 ©M comp2.
(=>
      (instance ?CONNECTION EngineeringConnection)
      (exists
            (?COMP1 ?COMP2)
            (connectsEngineeringComponents ?CONNECTION ?COMP1 ?COMP2)))

If group ¬O ¸sÅé ªº ¹ê¨Ò and memb ¬O groupªº ¦¨­û, then memb ¬O ¬I¨ÆªÌ ªº ¹ê¨Ò.
(=>
      (and
            (instance ?GROUP Group)
            (member ?MEMB ?GROUP))
      (instance ?MEMB Agent))

(=>
      (instance ?GROUP AgeGroup)
      (forall
            (?MEMB1 ?MEMB2 ?AGE1 ?AGE2)
            (=>
                  (and
                        (member ?MEMB1 ?GROUP)
                        (member ?MEMB2 ?GROUP)
                        (age ?MEMB1 ?AGE1)
                        (age ?MEMB2 ?AGE2))
                  (equal ?AGE1 ?AGE2))))

(=>
      (instance ?GROUP FamilyGroup)
      (forall
            (?MEMB1 ?MEMB2)
            (=>
                  (and
                        (member ?MEMB1 ?GROUP)
                        (member ?MEMB2 ?GROUP))
                  (familyRelation ?MEMB1 ?MEMB2))))

If organism1 ©M organism2 ¬ÛÃö, then there exists organism3 so that organism3 ©M organism1 ¬ÛÃö and organism3 ©M organism2 ¬ÛÃö.
(=>
      (familyRelation ?ORGANISM1 ?ORGANISM2)
      (exists
            (?ORGANISM3)
            (and
                  (familyRelation ?ORGANISM3 ?ORGANISM1)
                  (familyRelation ?ORGANISM3 ?ORGANISM2))))

If "unit ªº ¦Xªk ²Õ´ ¹êÅé " µ¥©ó org and attr ¬O ³W½dÄÝ©Ê ªº ¹ê¨Ò, then attr ¬O unit ªº ÄÝ©Ê if and only if attr ¬O org ªº ÄÝ©Ê.
(=>
      (and
            (equal
                  (OrganizationFn ?UNIT)
                  ?ORG)
            (instance ?ATTR NormativeAttribute))
      (<=>
            (attribute ?UNIT ?ATTR)
            (attribute ?ORG ?ATTR)))

If org (¨S) ¶±¥Înot(s) person, then person ¬O orgªº ¦¨­û.
(=>
      (employs ?ORG ?PERSON)
      (member ?PERSON ?ORG))

If pol ¬O ¬Fªv²Õ´ ªº ¹ê¨Ò, then there exists ¬Fªv¾úµ{ proc so that proc ¬O pol ªº ¬I¨ÆªÌ.
(=>
      (instance ?POL PoliticalOrganization)
      (exists
            (?PROC)
            (and
                  (instance ?PROC PoliticalProcess)
                  (agent ?PROC ?POL))))

If plan ¬O ­pµe ªº ¹ê¨Ò and obj ¬O ¤º®e¸üÅé ªº ¹ê¨Ò and obj (¤£) ¥]§ts) °T®§ %2, then there exists ­pµe planning so that obj ¬O planning ªº µ²ªG.
(=>
      (and
            (instance ?PLAN Plan)
            (instance ?OBJ ContentBearingObject)
            (containsInformation ?OBJ ?PLAN))
      (exists
            (?PLANNING)
            (and
                  (instance ?PLANNING Planning)
                  (result ?PLANNING ?OBJ))))

If plan ¬O ­pµe ªº ¹ê¨Ò, then there exists purp so that plan ¦³ ·N¹Ï purp.
(=>
      (instance ?PLAN Plan)
      (exists
            (?PURP)
            (hasPurpose ?PLAN ?PURP)))

If obj1 ¹ï obj2 ¬O attr1 and ¹ï¥ß©ó ? and attr1 ¬O "()" ªº ¤@ ¦¨­û and attr2 ¬O "()" ªº ¤@ ¦¨­û and attr1 µ¥©ó attr2, then obj1 ¹ï obj2 ¬O not attr2.
(=>
      (and
            (orientation ?OBJ1 ?OBJ2 ?ATTR1)
            (contraryAttribute @ROW)
            (inList
                  ?ATTR1
                  (ListFn @ROW))
            (inList
                  ?ATTR2
                  (ListFn @ROW))
            (not
                  (equal ?ATTR1 ?ATTR2)))
      (not
            (orientation ?OBJ1 ?OBJ2 ?ATTR2)))

(=>
      (holdsDuring
            ?TIME
            (direction ?PROC ?ATTR1))
      (forall
            (?ATTR2)
            (=>
                  (holdsDuring
                        ?TIME
                        (direction ?PROC ?ATTR2))
                  (equal ?ATTR2 ?ATTR1))))

(=>
      (holdsDuring
            ?TIME
            (faces ?PROC ?ATTR1))
      (forall
            (?ATTR2)
            (=>
                  (holdsDuring
                        ?TIME
                        (faces ?PROC ?ATTR2))
                  (equal ?ATTR2 ?ATTR1))))

If item ¦³ ÄÝ©Ê value and value ¬O ¯u­È ªº ¹ê¨Ò, then item ¬O ¥y¤l ªº ¹ê¨Ò or item ¬O ©RÃD ªº ¹ê¨Ò.
(=>
      (and
            (property ?ITEM ?VALUE)
            (instance ?VALUE TruthValue))
      (or
            (instance ?ITEM Sentence)
            (instance ?ITEM Proposition)))

If formula ¦³ ÄÝ©Ê ¥i¯àªº, then ""formula &$¬O ¯uªº" ªº ©ÎµM²v" (¤£) ¤j©ó ""formula &$¬O °²ªº" ªº ©ÎµM²v".
(=>
      (property ?FORMULA Likely)
      (greaterThan
            (ProbabilityFn
                  (true ?FORMULA True))
            (ProbabilityFn
                  (true ?FORMULA False))))

If formula ¦³ ÄÝ©Ê ¤£¤Ó¥i¯àªº, then ""formula &$¬O °²ªº" ªº ©ÎµM²v" (¤£) ¤j©ó ""formula &$¬O ¯uªº" ªº ©ÎµM²v".
(=>
      (property ?FORMULA Unlikely)
      (greaterThan
            (ProbabilityFn
                  (true ?FORMULA False))
            (ProbabilityFn
                  (true ?FORMULA True))))

If obj1 ¹ï obj2 ¬O attr1 and attr1 ¬O ¤è¦VÄÝ©Ê ªº ¹ê¨Ò and attr2 ¬O ¤è¦VÄÝ©Ê ªº ¹ê¨Ò and attr1 µ¥©ó attr2, then obj1 ¹ï obj2 ¬O not attr2.
(=>
      (and
            (orientation ?OBJ1 ?OBJ2 ?ATTR1)
            (instance ?ATTR1 DirectionalAttribute)
            (instance ?ATTR2 DirectionalAttribute)
            (not
                  (equal ?ATTR1 ?ATTR2)))
      (not
            (orientation ?OBJ1 ?OBJ2 ?ATTR2)))

If direct ¬O ¤è¦VÄÝ©Ê ªº ¹ê¨Ò and obj1 ¹ï obj2 ¬O direct and obj2 ¹ï obj3 ¬O direct, then obj2 ¤¶©ó obj1 ©M obj33 ¤¤¶¡.
(=>
      (and
            (instance ?DIRECT DirectionalAttribute)
            (orientation ?OBJ1 ?OBJ2 ?DIRECT)
            (orientation ?OBJ2 ?OBJ3 ?DIRECT))
      (between ?OBJ1 ?OBJ2 ?OBJ33))

If obj1 ¹ï obj2 ¬O ¦b...¤§¤W, then obj1 »P obj2 ¬Û³s.
(=>
      (orientation ?OBJ1 ?OBJ2 Above)
      (not
            (connected ?OBJ1 ?OBJ2)))

If obj1 ¹ï obj2 ¬O ¦b...¤§¤U, then obj2 ¹ï obj1 ¬O ¦b...¤W or obj2 ¹ï obj1 ¬O ¦b...¤§¤W.
(=>
      (orientation ?OBJ1 ?OBJ2 Below)
      (or
            (orientation ?OBJ2 ?OBJ1 On)
            (orientation ?OBJ2 ?OBJ1 Above)))

If obj1 ¹ï obj2 ¬O ¾Fªñªº, then obj1 ¹ï obj2 ¬O ±µªñ or obj1 »P obj2 ¬Û³s.
(=>
      (orientation ?OBJ1 ?OBJ2 Adjacent)
      (or
            (orientation ?OBJ1 ?OBJ2 Near)
            (connected ?OBJ1 ?OBJ2)))

If obj1 ¹ï obj2 ¬O ±µªñ, then obj1 »P obj2 ¬Û³s.
(=>
      (orientation ?OBJ1 ?OBJ2 Near)
      (not
            (connected ?OBJ1 ?OBJ2)))

If obj1 ¹ï obj2 ¬O ±µªñ, then obj2 ¹ï obj1 ¬O ±µªñ.
(=>
      (orientation ?OBJ1 ?OBJ2 Near)
      (orientation ?OBJ2 ?OBJ1 Near))

If obj1 ¹ï obj2 ¬O ¦b...¤W, then obj1 »P obj2 ¬Û³s.
(=>
      (orientation ?OBJ1 ?OBJ2 On)
      (connected ?OBJ1 ?OBJ2))

If obj1 ¹ï obj2 ¬O ¦b...¤W, then obj1 ¦ì©ó obj2.
(=>
      (orientation ?OBJ1 ?OBJ2 On)
      (located ?OBJ1 ?OBJ2))

If obj1 ¹ï obj2 ¬O ¦b...¤W, then obj2 ¹ï obj1 ¬O not ¦b...¤W.
(=>
      (orientation ?OBJ1 ?OBJ2 On)
      (not
            (orientation ?OBJ2 ?OBJ1 On)))

If "¬Û¹ï®É¶¡¨ç¼Æ" µ¥©ó time2, then time2 µ¥©ó "(time1+)".
(=>
      (equal
            (RelativeTimeFn ?TIME1 PacificTimeZone)
            ?TIME2)
      (equal
            ?TIME2
            (AdditionFn ?TIME1 8)))

If "¬Û¹ï®É¶¡¨ç¼Æ" µ¥©ó time2, then time2 µ¥©ó "(time1+)".
(=>
      (equal
            (RelativeTimeFn ?TIME1 MountainTimeZone)
            ?TIME2)
      (equal
            ?TIME2
            (AdditionFn ?TIME1 7)))

If "¬Û¹ï®É¶¡¨ç¼Æ" µ¥©ó time2, then time2 µ¥©ó "(time1+)".
(=>
      (equal
            (RelativeTimeFn ?TIME1 CentralTimeZone)
            ?TIME2)
      (equal
            ?TIME2
            (AdditionFn ?TIME1 6)))

If "¬Û¹ï®É¶¡¨ç¼Æ" µ¥©ó time2, then time2 µ¥©ó "(time1+)".
(=>
      (equal
            (RelativeTimeFn ?TIME1 EasternTimeZone)
            ?TIME2)
      (equal
            ?TIME2
            (AdditionFn ?TIME1 5)))

If attribute ¬O person ªº ÄÝ©Ê and attribute ¬O ªÀ·|¨¤¦â ªº ¹ê¨Ò, then person ¬O ¤HÃþ ªº ¹ê¨Ò.
(=>
      (and
            (attribute ?PERSON ?ATTRIBUTE)
            (instance ?ATTRIBUTE SocialRole))
      (instance ?PERSON Human))

If org (¨S) ¶±¥Înot(s) person, then there exists position so that person ¦û position ªº ¾¦ì ¦b org.
(=>
      (employs ?ORG ?PERSON)
      (exists
            (?POSITION)
            (occupiesPosition ?PERSON ?POSITION ?ORG)))

If ³¯­z formula1 ¦³ prop ªº «¬ºA·N¸q and ±Àª¾(formula1,formula2) holds, then ³¯­z formula2 ¦³ prop ªº «¬ºA·N¸q.
(=>
      (and
            (modalAttribute ?FORMULA1 ?PROP)
            (entails ?FORMULA1 ?FORMULA2))
      (modalAttribute ?FORMULA2 ?PROP))

If agent ¦³¸q°È °õ¦æ Ãþ«¬ process ¥ô°È, then ³¯­z "there exists process instance so that instance ¬O agent ªº ¬I¨ÆªÌ" ¦³ ¸q°È ªº «¬ºA·N¸q.
(=>
      (holdsObligation ?PROCESS ?AGENT)
      (modalAttribute
            (exists
                  (?INSTANCE)
                  (and
                        (instance ?INSTANCE ?PROCESS)
                        (agent ?INSTANCE ?AGENT)))
            Obligation))

If agent ¦³ Åv ¨Ï process ¬°¯u, then ³¯­z "there exists process instance so that instance ¬O agent ªº ¬I¨ÆªÌ" ¦³ ³\¥i ªº «¬ºA·N¸q.
(=>
      (holdsRight ?PROCESS ?AGENT)
      (modalAttribute
            (exists
                  (?INSTANCE)
                  (and
                        (instance ?INSTANCE ?PROCESS)
                        (agent ?INSTANCE ?AGENT)))
            Permission))

If attr ¬O obj ªº ÄÝ©Ê and attr ¬O Ävª§ÄÝ©Ê ªº ¹ê¨Ò, then there exists Ävª§ contest so that contest ¬O obj ªº ¬I¨ÆªÌ or obj ¬O contest ªº ¨ü¨ÆªÌ.
(=>
      (and
            (attribute ?OBJ ?ATTR)
            (instance ?ATTR ContestAttribute))
      (exists
            (?CONTEST)
            (and
                  (instance ?CONTEST Contest)
                  (or
                        (agent ?CONTEST ?OBJ)
                        (patient ?CONTEST ?OBJ)))))

If ³¯­z formula ¦³ ¥²­n©Ê ªº «¬ºA·N¸q, then ³¯­z formula ¦³ ¥i¯à©Ê ªº «¬ºA·N¸q.
(=>
      (modalAttribute ?FORMULA Necessity)
      (modalAttribute ?FORMULA Possibility))

If ³¯­z formula ¦³ ¸q°È ªº «¬ºA·N¸q, then ³¯­z formula ¦³ ³\¥i ªº «¬ºA·N¸q.
(=>
      (modalAttribute ?FORMULA Obligation)
      (modalAttribute ?FORMULA Permission))

If entity ¦³ ÄÝ©Ê ©Ó¿Õ, then entity ¦³ ÄÝ©Ê «´¬ù or entity ¦³ ÄÝ©Ê ³æ¤è©Ó¿Õ.
(=>
      (property ?ENTITY Promise)
      (or
            (property ?ENTITY Contract)
            (property ?ENTITY NakedPromise)))

If obj ¬O ·»²G ªº ¹ê¨Ò, then ²GÅ骺 ¬O obj ªº ÄÝ©Ê.
(=>
      (instance ?OBJ Solution)
      (attribute ?OBJ Liquid))

If perception ¬O ª¾Ä± ªº ¹ê¨Ò and obj ¬O perception ªº ¨ü¨ÆªÌ, then there exists ª¾Ä±ÄÝ©Ê prop so that prop ¬O obj ªº ÄÝ©Ê.
(=>
      (and
            (instance ?PERCEPTION Perception)
            (patient ?PERCEPTION ?OBJ))
      (exists
            (?PROP)
            (and
                  (instance ?PROP PerceptualAttribute)
                  (attribute ?OBJ ?PROP))))

If obj ¬O ­¹ª« ªº ¹ê¨Ò, then there exists ¨ýıÄÝ©Ê attr so that attr ¬O obj ªº ÄÝ©Ê.
(=>
      (instance ?OBJ Food)
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR TasteAttribute)
                  (attribute ?OBJ ?ATTR))))

(=>
      (and
            (attribute ?OBJ Monochromatic)
            (superficialPart ?PART ?OBJ)
            (attribute ?PART ?COLOR)
            (instance ?COLOR PrimaryColor))
      (forall
            (?ELEMENT)
            (=>
                  (superficialPart ?ELEMENT ?OBJ)
                  (attribute ?ELEMENT ?COLOR))))

If obj ¬O ª«Åé ªº ¹ê¨Ò, then ³æ¦âªº ¬O obj ªº ÄÝ©Ê or ¦h±mªº ¬O obj ªº ÄÝ©Ê.
(=>
      (instance ?OBJ Object)
      (or
            (attribute ?OBJ Monochromatic)
            (attribute ?OBJ Polychromatic)))

If ¦h±mªº ¬O obj ªº ÄÝ©Ê, then there exist part1,part2,ÃC¦âÄÝ©Ê color1,ÃC¦âÄÝ©Ê color2 so that part1 ¬O objªº ¥~ªí³¡¤À and part2 ¬O objªº ¥~ªí³¡¤À and color1 ¬O part1 ªº ÄÝ©Ê and color2 ¬O part2 ªº ÄÝ©Ê and color1 µ¥©ó color2.
(=>
      (attribute ?OBJ Polychromatic)
      (exists
            (?PART1 ?PART2 ?COLOR1 ?COLOR2)
            (and
                  (superficialPart ?PART1 ?OBJ)
                  (superficialPart ?PART2 ?OBJ)
                  (attribute ?PART1 ?COLOR1)
                  (attribute ?PART2 ?COLOR2)
                  (instance ?COLOR1 ColorAttribute)
                  (instance ?COLOR2 ColorAttribute)
                  (not
                        (equal ?COLOR1 ?COLOR2)))))

If there exists §Îª¬§ïÅÜ change so that obj ¬O change ªº ¨ü¨ÆªÌ, then ¥iÅܧΪº ¬O obj ªº ÄÝ©Ê.
(=>
      (exists
            (?CHANGE)
            (and
                  (instance ?CHANGE ShapeChange)
                  (patient ?CHANGE ?OBJ)))
      (attribute ?OBJ Pliable))

If obj ¬O ¦Û¨­³sÄòª«Åé ªº ¹ê¨Ò, then ¥iÅܧΪº ¬O obj ªº ÄÝ©Ê or ¤£©öÅs¦±ªº ¬O obj ªº ÄÝ©Ê.
(=>
      (instance ?OBJ SelfConnectedObject)
      (or
            (attribute ?OBJ Pliable)
            (attribute ?OBJ Rigid)))

If attribute ¬O ¡]ªí­±¡^½è¦aÄÝ©Ê ªº ¹ê¨Ò and attribute ¬O obj ªº ÄÝ©Ê and surface ¬O obj ªº ªí­±, then attribute ¬O surface ªº ÄÝ©Ê.
(=>
      (and
            (instance ?ATTRIBUTE TextureAttribute)
            (attribute ?OBJ ?ATTRIBUTE)
            (surface ?SURFACE ?OBJ))
      (attribute ?SURFACE ?ATTRIBUTE))

If °®ªº ¬O obj ªº ÄÝ©Ê, then there doesn't exist subobj so that subobj ¬O obj ªº ³¡¤À) and ²GÅ骺 ¬O subobj ªº ÄÝ©Ê.
(=>
      (attribute ?OBJ Dry)
      (not
            (exists
                  (?SUBOBJ)
                  (and
                        (part ?SUBOBJ ?OBJ)
                        (attribute ?SUBOBJ Liquid)))))

(=>
      (attribute ?OBJ Wet)
      (forall
            (?PART)
            (=>
                  (part ?PART ?OBJ)
                  (exists
                        (?SUBPART)
                        (and
                              (part ?SUBPART ?PART)
                              (attribute ?SUBPART Liquid))))))

If ¤£©ö¸Hªº ¬O obj ªº ÄÝ©Ê, then there doesn't exist ·l®` damage so that obj ¬O damage ªº ¨ü¨ÆªÌ.
(=>
      (attribute ?OBJ Unbreakable)
      (not
            (exists
                  (?DAMAGE)
                  (and
                        (instance ?DAMAGE Damaging)
                        (patient ?DAMAGE ?OBJ)))))

If att ¬O org ªº ÄÝ©Ê and att ¬O ¥Íª«ÄÝ©Ê ªº ¹ê¨Ò, then org ¬O ¥Íª«Åé ªº ¹ê¨Ò.
(=>
      (and
            (attribute ?ORG ?ATT)
            (instance ?ATT BiologicalAttribute))
      (instance ?ORG Organism))

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 org ¬O ¥Íª«Åé ªº ¹ê¨Ò, then there exists ¦³¥ÍÄÝ©Ê attr so that attr ¬O org ªº ÄÝ©Ê.
(=>
      (instance ?ORG Organism)
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR AnimacyAttribute)
                  (attribute ?ORG ?ATTR))))

If body ¬O ¥Í´Þºc³y ªº ¹ê¨Ò and body ¬O org ªº ³¡¤À) and org ¬O ¥Íª«Åé ªº ¹ê¨Ò, then »Û©Ê ¬O org ªº ÄÝ©Ê.
(=>
      (and
            (instance ?BODY ReproductiveBody)
            (part ?BODY ?ORG)
            (instance ?ORG Organism))
      (attribute ?ORG Female))

If animal ¬O °Êª« ªº ¹ê¨Ò, then there exists ©Ê§OÄÝ©Ê attr so that attr ¬O animal ªº ÄÝ©Ê.
(=>
      (instance ?ANIMAL Animal)
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR SexAttribute)
                  (attribute ?ANIMAL ?ATTR))))

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)))))

If org ¬O ¥Íª«Åé ªº ¹ê¨Ò, then there exists µo®iÄÝ©Ê attr so that attr ¬O org ªº ÄÝ©Ê.
(=>
      (instance ?ORG Organism)
      (exists
            (?ATTR)
            (and
                  (instance ?ATTR DevelopmentalAttribute)
                  (attribute ?ORG ?ATTR))))

If ¥®Å骺 ¬O org ªº ÄÝ©Ê timea(¤§¤¤) time, then there exists ½Ï¥Í birth so that org (¨S) ÅéÅçnot(s) birth "time ¤§«e"a(¤§¤¤) time ¤§«e.
(=>
      (holdsDuring
            ?TIME
            (attribute ?ORG Larval))
      (holdsDuring
            (PastFn ?TIME)
            (exists
                  (?BIRTH)
                  (and
                        (instance ?BIRTH Birth)
                        (experiencer ?BIRTH ?ORG)))))

If ­F­Lªº ¬O org ªº ÄÝ©Ê, then there exists ¥Í´Þºc³y body so that org ¦ì©ó body.
(=>
      (attribute ?ORG Embryonic)
      (exists
            (?BODY)
            (and
                  (instance ?BODY ReproductiveBody)
                  (located ?ORG ?BODY))))

If ­F­Lªº ¬O org ªº ÄÝ©Ê timea(¤§¤¤) time, then there doesn't exist ½Ï¥Í birth so that org (¨S) ÅéÅçnot(s) birth timea(¤§¤¤) time.
(=>
      (holdsDuring
            ?TIME
            (attribute ?ORG Embryonic))
      (holdsDuring
            ?TIME
            (not
                  (exists
                        (?BIRTH)
                        (and
                              (instance ?BIRTH Birth)
                              (experiencer ?BIRTH ?ORG))))))

(=>
      (instance ?ATTR PsychologicalAttribute)
      (=>
            (holdsDuring
                  ?TIME
                  (attribute ?ORGANISM ?ATTR))
            (holdsDuring
                  ?TIME
                  (attribute ?ORGANISM Living))))

If attr ¬O ¤ß²zÄÝ©Ê ªº ¹ê¨Ò and attr ¬O agent ªº ÄÝ©Ê, then agent ¬O ¯àª¾Ä±ªº¦æ¬°¥DÅé ªº ¹ê¨Ò.
(=>
      (and
            (instance ?ATTR PsychologicalAttribute)
            (attribute ?AGENT ?ATTR))
      (instance ?AGENT SentientAgent))

If class1 ¬O ¶°¦X©ÎºØÃþ ªº ¹ê¨Ò and class2 ¬O ¶°¦X©ÎºØÃþ ªº ¹ê¨Ò, then "class1 ©M class2 ªº ®t²§" µ¥©ó "class1 ©M "class2 ªº ¤¬¸É" ªº Áp¶°".
(=>
      (and
            (instance ?CLASS1 SetOrClass)
            (instance ?CLASS2 SetOrClass))
      (equal
            (RelativeComplementFn ?CLASS1 ?CLASS2)
            (IntersectionFn
                  ?CLASS1
                  (ComplementFn ?CLASS2))))

entity ¬O "superclass ªº ©Ò¦³ ¤¸¯À ªº ¥æ¶°" ªº ¹ê¨Ò if and only if for all class holds: if class ¬O superclass ªº ¹ê¨Ò, then entity ¬O class ªº ¹ê¨Ò.
(<=>
      (instance
            ?ENTITY
            (GeneralizedIntersectionFn ?SUPERCLASS))
      (forall
            (?CLASS)
            (=>
                  (instance ?CLASS ?SUPERCLASS)
                  (instance ?ENTITY ?CLASS))))