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

xu4 lie4 han2 shu4 (ListFn)

A Function that takes any number of arguments and returns the List containing those arguments in exactly the same order.

Ontology

SUMO / BASE-ONTOLOGY

Class(es)

zhong3 lei4
is instance of
  ke3 ji4 cheng2 guan1 xi4  
is instance of
  han2 shu4  
is instance of
bian4 yi4 yuan2 shu4 guan1 xi4
is instance of

is instance of
  xu4 lie4 han2 shu4  

Coordinate term(s)

zhi3 ding4 han2 shu4  zui4 da4 gong1 yue1 shu4 han2 shu4  zui4 xiao3 gong1 bei4 shu4 han2 shu4  mao2 dun4 shu3 xing4  wu2 jiao1 ji2 fen1 jie3  wu2 jiao1 ji2 guan1 xi4  qiong2 jin4 de5 shu3 xing4  qiong2 jin4 de5 fen1 jie3  cheng2 li4  fen1 ge1 

Axioms (27)

(=>
      (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 wu2 jiao1 ji2 guan1 xi4() holds and rel shi4 "()" de5 yi1 cheng2 yuan2, then rel shi4 guan1 xi4 de5 shi2 li4.
(=>
      (and
            (disjointRelation @ROW)
            (inList
                  ?REL
                  (ListFn @ROW)))
      (instance ?REL Relation))

If wu2 jiao1 ji2 guan1 xi4() holds and rel1 shi4 "()" de5 yi1 cheng2 yuan2 and rel2 shi4 "()" de5 yi1 cheng2 yuan2 and rel1 %&有 論元(s) number, then rel2 %&有 論元(s) number.
(=>
      (and
            (disjointRelation @ROW)
            (inList
                  ?REL1
                  (ListFn @ROW))
            (inList
                  ?REL2
                  (ListFn @ROW))
            (valence ?REL1 ?NUMBER))
      (valence ?REL2 ?NUMBER))

If wu2 jiao1 ji2 guan1 xi4() holds and rel1 shi4 "()" de5 yi1 cheng2 yuan2 and rel2 shi4 "()" de5 yi1 cheng2 yuan2 and rel1 deng3 yu1 rel2 and rel1() (bu2) cheng2 li4s, then rel2() not(bu2) cheng2 li4.
(=>
      (and
            (disjointRelation @ROW1)
            (inList
                  ?REL1
                  (ListFn @ROW1))
            (inList
                  ?REL2
                  (ListFn @ROW1))
            (not
                  (equal ?REL1 ?REL2))
            (holds ?REL1 @ROW2))
      (not
            (holds ?REL2 @ROW2)))

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

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

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

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

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

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

rel shi4 quan2 zhi2 guan1 xi4 de5 shi2 li4 if and only if there exists valence so_that_not rel shi4 guan1 xi4 de5 shi2 li4 and rel %&有 論元(s) valence and
(<=>
      (instance ?REL TotalValuedRelation)
      (exists
            (?VALENCE)
            (and
                  (instance ?REL Relation)
                  (valence ?REL ?VALENCE)
                  (=>
                        (forall
                              (?NUMBER ?ELEMENT ?CLASS)
                              (=>
                                    (and
                                          (lessThan ?NUMBER ?VALENCE)
                                          (domain ?REL ?NUMBER ?CLASS)
                                          (equal
                                                ?ELEMENT
                                                (ListOrderFn
                                                      (ListFn @ROW)
                                                      ?NUMBER)))
                                    (instance ?ELEMENT ?CLASS)))
                        (exists
                              (?ITEM)
                              (holds ?REL @ROW ?ITEM))))))

If rel shi4 yi4 tu2 guan1 xi4 de5 shi2 li4 and rel(agent,) (bu2) cheng2 li4s and obj shi4 "()" de5 yi1 cheng2 yuan2, then agent zai4 obj fan4 wei2 zhong1.
(=>
      (and
            (instance ?REL IntentionalRelation)
            (holds ?REL ?AGENT @ROW)
            (inList
                  ?OBJ
                  (ListFn @ROW)))
      (inScopeOfInterest ?AGENT ?OBJ))

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

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

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

If rel de5 lun4 yuan2 number shi4 class de5 shi2 li4 and rel() (bu2) cheng2 li4s, then ""()" de5 di4 er4 yuan2 su4" shi4 class de5 shi2 li4.
(=>
      (and
            (domain ?REL ?NUMBER ?CLASS)
            (holds ?REL @ROW))
      (instance
            (ListOrderFn
                  (ListFn @ROW)
                  ?NUMBER)
            ?CLASS))

If rel de5 lun4 yuan2 number shi4 class de5 ci4 zhong3 lei4 and rel() (bu2) cheng2 li4s, then ""()" de5 di4 er4 yuan2 su4" shi4 class de5 ci4 zhong3 lei4.
(=>
      (and
            (domainSubclass ?REL ?NUMBER ?CLASS)
            (holds ?REL @ROW))
      (subclass
            (ListOrderFn
                  (ListFn @ROW)
                  ?NUMBER)
            ?CLASS))

""(,item)" de5 chang2 du4" deng3 yu1 "(""()" de5 chang2 du4"+1)".
(equal
      (ListLengthFn
            (ListFn @ROW ?ITEM))
      (SuccessorFn
            (ListLengthFn
                  (ListFn @ROW))))

""(,item)" de5 di4 er4 yuan2 su4" deng3 yu1 item.
(equal
      (ListOrderFn
            (ListFn @ROW ?ITEM)
            (ListLengthFn
                  (ListFn @ROW ?ITEM)))
      ?ITEM)

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

"()" (mei2chu1 shi3 hua4not(s) "(,item)".
(initialList
      (ListFn @ROW)
      (ListFn @ROW ?ITEM))

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

(=>
      (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 obj1 dui4 obj2 shi4 attr1 and dui4 li4 yu1 ? and attr1 shi4 "()" de5 yi1 cheng2 yuan2 and attr2 shi4 "()" de5 yi1 cheng2 yuan2 and attr1 deng3 yu1 attr2, then obj1 dui4 obj2 shi4 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)))