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

¬Ûµ¥ (equal)

(equal entity1 entity2) is true just in case entity1 is identical with entity2.

Ontology

SUMO / STRUCTURAL-ONTOLOGY

Class(es)

ºØÃþ
is instance of
  ¥iÄ~©ÓÃö«Y  
is instance of
  ¤G¤¸­zµü  
is instance of
µ¥¦PÃö«Y
is instance of
ºØÃþ
is instance of
  ¥iÄ~©ÓÃö«Y  
is instance of
  »P¶qÃö«Y  
is instance of

is instance of
  ¬Ûµ¥  

Coordinate term(s)

¥[ªk¨ç¼Æ  °£ªk¨ç¼Æ  «ü¼Æ¨ç¼Æ  ³Ì¤j­È¨ç¼Æ  ³Ì¤p­È¨ç¼Æ  ­¼ªk¨ç¼Æ  ­Ë¼Æ¨ç¼Æ  ¾l¼Æ¨ç¼Æ  ¾ã¼Æ¨ç¼Æ  ´îªk¨ç¼Æ  ©·½u­«¶q  §@ªÌ  ¥ý©ó©Î¦P®É  »F¦]  ¦¸Ãþ»F¦]  ¤½¥Á  «Ê³¬©ó  ¬Û³sªº  ¥]§t°T®§  ¦@¥Í  ½Æ»s  ¤é´Á  ­°§C¥i¯à©Ê  µo®i´Á§Î¦¡  µL¥æ¶°  ¤À°t  ¤å¦r»¡©ú  «ùÄò®É¶¡  ¸û¦­  ½sªÌ  ¤¸¯À  ¶±¥Î  µ¥¦PÃö«Y©ó  °T®§µ¥¦PÃþ  °T®§µ¥¦Pª«  §Q¥Î  ¥H...»y¨¥ªí¹F  ­±¹ï  ®a±ÚÃö«Y  §¹¦¨  ¦¸¼Æ  ¹Ï³¡¤À  ¤j©ó  ¤j©ó©Îµ¥©ó  ¦³·N¹Ï  ¦³§Þ¥©  ¦b...´Á¶¡¬°¯u  ¶·¨Ï...¬°¯u  ¦³Åv¨Ï...¬°¯u  ¬}  ¦P¤@¤¸¯À  ¦ê¦C¤¤  ¦bª`·N½d³ò¤¤  ¼W¥[¥i¯à©Ê  ¿W¥ß©ÎµM²v  ©~¦í  §í¨î  ªì©l¤Æ§Ç¦C  ¹ê¨Ò  ­Ë§Ç  «D¤Ï®g©ó...  ¤j©ó  ¤p©ó  ¤p©ó©Îµ¥©ó  ª«½è  ´ú¶q  ®É¬q¬Û±µ  ±¡ºAÄݩʠ ®É¬q­«Å|  Âù¿Ë  °¾§Ç©ó...  ³¡¤À¦ì©ó  ¸ô®|ªø  ¾Ö¦³  ¥ý¨M±ø¥ó  Á×§K  ¯S©Ê  ¥Xª©  ½d³ò  ½d³ò¦¸ºØÃþ  ´£¤Î  ¤Ï®g©ó...  SUMO¤º³¡¬ÛÃö·§©À  ¥S§Ì©n©f  ¤p©ó  ¶}©l  ¦¸Äݩʠ ¦¸»E¶°  ¦¸¹Ï  ¦¸§Ç¦C  ¦¸¾úµ{  ¦¸©RÃD  ¦¸ºØÃþ  ¦¸Ãö«Y  ¥]§t°T®§ºØÃþ  ¥]§t°T®§¹ê¨Ò  Äò±µÄݩʠ «Ê³¬Äò±µÄݩʠ ®É¶¡³¡¤À  ®É¶¡  ¥þ§Ç©ó...  ¤T¤Àªk  ¨Ï¥Î  ¡]µ²¦X¡^»ù  ¤H³yª«ª©¥» 

Type restrictions

equal(¹êÅé, ¹êÅé)

Related WordNet synsets

sameness
the quality of being alike: "sameness of purpose kept them together"
sameness is opposite to...   sameness is kind of (all)...   sameness is kind of...   kinds of sameness...   kinds of sameness (all)...   sameness is an attribute of  
identity, identicalness, indistinguishability
exact sameness; "they shared an identity of interests"
identity is kind of (all)...   identity is kind of...   kinds of identity...   kinds of identity (all)...  
equality
the quality or state of being the same in quantity or measure or value or status
equality is opposite to...   equality is kind of (all)...   equality is kind of...   kinds of equality...   kinds of equality (all)...   equality is an attribute of  
equivalence
essential equality and interchangeability
equivalence is opposite to...   equivalence is kind of (all)...   equivalence is kind of...   kinds of equivalence...   kinds of equivalence (all)...  
equatability
capability of being equated
equatability is kind of (all)...   equatability is kind of...  
changelessness
the property of remaining unchanged
changelessness is kind of (all)...   changelessness is kind of...  
equivalent
a person or thing equal to another in value or measure or force or effect or significance etc: "send two dollars or the equivalent in stamps"
equivalent is kind of (all)...   equivalent is kind of...   kinds of equivalent...   kinds of equivalent (all)...  
equate, correspond
be equivalent or parallel, in mathematics
equate is kind of (all)...   equate is kind of...  
equal, be
be identical or equivalent to: "One dollar equals 1,000 rubles these days!"
equal is opposite to...   kinds of equal...   kinds of equal (all)...  
equal
well matched; having the same quantity, value, or measure as another; "on equal terms"; "all men are equal before the law"
equal is opposite to...   see also...   equal is similar to...   equal is an attribute of  
like, equal, equivalent, same
equal in amount or value; "like amounts"; "equivalent amounts"; "the same amount"; "gave one six blows and the other a like number"; "an equal number"; "the same number"
like is opposite to...  
same
same in identity; "the same man I saw yesterday"; "never wore the same dress twice"; "this road is the same one we were on yesterday"; "on the same side of the street"
same is opposite to...   same is similar to...  
See more related synsets on a separate page.

Axioms (245)

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 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 ³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 µ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)
      (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)
      (forall
            (?OBJ)
            (=>
                  (instance ?ATTR1 ?CLASS)
                  (exists
                        (?ATTR2)
                        (and
                              (inList
                                    ?ATTR2
                                    (ListFn @ROW))
                              (equal ?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))

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

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

"class ªº ´y­z" µ¥©ó attr if and only if for all inst holds: inst ¬O class ªº ¹ê¨Ò if and only if inst ¦³ ÄÝ©Ê attr.
(<=>
      (equal
            (AbstractionFn ?CLASS)
            ?ATTR)
      (forall
            (?INST)
            (<=>
                  (instance ?INST ?CLASS)
                  (property ?INST ?ATTR))))

"ºØÃþ ²Å¦X attribute" µ¥©ó class if and only if "class ªº ´y­z" µ¥©ó attribute.
(<=>
      (equal
            (ExtensionFn ?ATTRIBUTE)
            ?CLASS)
      (equal
            (AbstractionFn ?CLASS)
            ?ATTRIBUTE))

number1 ¤p©ó©Îµ¥©ó number2 if and only if number1 µ¥©ó number2 or number1 ¤p©ó number2.
(<=>
      (lessThanOrEqualTo ?NUMBER1 ?NUMBER2)
      (or
            (equal ?NUMBER1 ?NUMBER2)
            (lessThan ?NUMBER1 ?NUMBER2)))

number1 ¤j©ó©Îµ¥©ó number2 if and only if number1 µ¥©ó number2 or number1 (¤£) ¤j©ó number2.
(<=>
      (greaterThanOrEqualTo ?NUMBER1 ?NUMBER2)
      (or
            (equal ?NUMBER1 ?NUMBER2)
            (greaterThan ?NUMBER1 ?NUMBER2)))

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

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

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

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

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

list µ¥©ó ªÅ¦C if and only if there doesn't exist item so that item ¬O list ªº ¤@ ¦¨­û.
(<=>
      (equal ?LIST NullList)
      (not
            (exists
                  (?ITEM)
                  (inList ?ITEM ?LIST))))

(=>
      (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 "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))))

""(,item)" ªº ªø«×" µ¥©ó "(""()" ªº ªø«×"+1)".
(equal
      (ListLengthFn
            (ListFn @ROW ?ITEM))
      (SuccessorFn
            (ListLengthFn
                  (ListFn @ROW))))

""(,item)" ªº ²Ä¤G ¤¸¯À" µ¥©ó item.
(equal
      (ListOrderFn
            (ListFn @ROW ?ITEM)
            (ListLengthFn
                  (ListFn @ROW ?ITEM)))
      ?ITEM)

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

item ¬O list ªº ¤@ ¦¨­û if and only if there exists number so that "list ªº ²Ä¤G ¤¸¯À" µ¥©ó item.
(<=>
      (inList ?ITEM ?LIST)
      (exists
            (?NUMBER)
            (equal
                  (ListOrderFn ?LIST ?NUMBER)
                  ?ITEM)))

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

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

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

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

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

"thing ¦b time ªº time¦ì¸m" µ¥©ó region if and only if thing ºë½T¦ì©ó region timea(¤§¤¤) time.
(<=>
      (equal
            (WhereFn ?THING ?TIME)
            ?REGION)
      (holdsDuring
            ?TIME
            (exactlyLocated ?THING ?REGION)))

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

"(number+1)" µ¥©ó "(number+)".
(equal
      (SuccessorFn ?NUMBER)
      (AdditionFn ?NUMBER 1))

"(number+2)" µ¥©ó "(number-)".
(equal
      (PredecessorFn ?NUMBER)
      (SubtractionFn ?NUMBER 1))

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

"number1 ªº µ´¹ï ­È" µ¥©ó number2 and number1 ¬O ¹ê¼Æ ªº ¹ê¨Ò and number2 ¬O ¹ê¼Æ ªº ¹ê¨Ò if and only if
(<=>
      (and
            (equal
                  (AbsoluteValueFn ?NUMBER1)
                  ?NUMBER2)
            (instance ?NUMBER1 RealNumber)
            (instance ?NUMBER2 RealNumber))
      (or
            (and
                  (instance ?NUMBER1 NonnegativeRealNumber)
                  (equal ?NUMBER1 ?NUMBER2))
            (and
                  (instance ?NUMBER1 NegativeRealNumber)
                  (equal
                        ?NUMBER2
                        (SubtractionFn 0 ?NUMBER1)))))

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

"number1 ¨ú¾l¼Æ number2" µ¥©ó number if and only if "(""³Ì¤j ¾ã¼Æ ¤p©ó ©Î µ¥©ó "number1/number2""*number2"+number)" µ¥©ó number1.
(<=>
      (equal
            (RemainderFn ?NUMBER1 ?NUMBER2)
            ?NUMBER)
      (equal
            (AdditionFn
                  (MultiplicationFn
                        (FloorFn
                              (DivisionFn ?NUMBER1 ?NUMBER2))
                        ?NUMBER2)
                  ?NUMBER)
            ?NUMBER1))

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 µ¥©ó "("(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 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)))))

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

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

graph ¬O ¹Ï§Î°j¸ô ªº ¹ê¨Ò if and only if there exists node so that "graph ªº ³Ìªì¸`ÂI" µ¥©ó node and "graph ªº ³Ì«á¸`ÂI" µ¥©ó node.
(<=>
      (instance ?GRAPH GraphCircuit)
      (exists
            (?NODE)
            (and
                  (equal
                        (BeginNodeFn ?GRAPH)
                        ?NODE)
                  (equal
                        (EndNodeFn ?GRAPH)
                        ?NODE))))

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

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

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

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

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

"person ªº °]²£ ªº »ù­È" µ¥©ó amount if and only if "person ªº ªþÄݪ«" ªº »ù­È ¬O amount.
(<=>
      (equal
            (WealthFn ?PERSON)
            ?AMOUNT)
      (monetaryValue
            (PropertyFn ?PERSON)
            ?AMOUNT))

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

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

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

interval1 (¨S) }©ls interval2 if and only if "interval1 ªº }©l" µ¥©ó "interval2 ªº }©l" and "interval1 ªº µ²§ô" (¨S) µo¥Í?{s} ¦b "interval2 ªº µ²§ô" ¤§«e.
(<=>
      (starts ?INTERVAL1 ?INTERVAL2)
      (and
            (equal
                  (BeginFn ?INTERVAL1)
                  (BeginFn ?INTERVAL2))
            (before
                  (EndFn ?INTERVAL1)
                  (EndFn ?INTERVAL2))))

interval1 (¨S) §¹¦¨s interval2 if and only if "interval2 ªº }©l" (¨S) µo¥Í?{s} ¦b "interval1 ªº }©l" ¤§«e and "interval2 ªº µ²§ô" µ¥©ó "interval1 ªº µ²§ô".
(<=>
      (finishes ?INTERVAL1 ?INTERVAL2)
      (and
            (before
                  (BeginFn ?INTERVAL2)
                  (BeginFn ?INTERVAL1))
            (equal
                  (EndFn ?INTERVAL2)
                  (EndFn ?INTERVAL1))))

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

interval1 (¨S) ¬Û±µs interval2 if and only if "interval1 ªº µ²§ô" µ¥©ó "interval2 ªº }©l".
(<=>
      (meetsTemporally ?INTERVAL1 ?INTERVAL2)
      (equal
            (EndFn ?INTERVAL1)
            (BeginFn ?INTERVAL2)))

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

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

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

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

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

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

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

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

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

compound ¬O ¤Æ¦Xª« ªº ¹ê¨Ò if and only if there exist °ò¥»ª«½è element1,°ò¥»ª«½è element2,¤Æ¾Ç¦X¦¨ process so that element1 µ¥©ó element2 and element1 ¹ï process ¬O ¸ê·½ and element2 ¹ï process ¬O ¸ê·½ and compound ¬O process ªº µ²ªG.
(<=>
      (instance ?COMPOUND CompoundSubstance)
      (exists
            (?ELEMENT1 ?ELEMENT2 ?PROCESS)
            (and
                  (instance ?ELEMENT1 ElementalSubstance)
                  (instance ?ELEMENT2 ElementalSubstance)
                  (not
                        (equal ?ELEMENT1 ?ELEMENT2))
                  (instance ?PROCESS ChemicalSynthesis)
                  (resource ?PROCESS ?ELEMENT1)
                  (resource ?PROCESS ?ELEMENT2)
                  (result ?PROCESS ?COMPOUND))))

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

"¤j³° ¤¤ ¹ê¨Ò ªº ¼Æ¥Ø" µ¥©ó .
(equal
      (CardinalityFn Continent)
      7)

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

(=>
      (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 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 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 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 "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 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 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)))))

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

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

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 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 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 "¬Û¹ï®É¶¡¨ç¼Æ" µ¥©ó 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 ¦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 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))))