ListeLängeFn (ListLengthFn)

A Function that takes a List as its sole argument and returns the number of items in the List. For example, (ListLengthFn (ListFn Monday Tuesday Wednesday)) would return the value 3.

Ontology

SUMO / BASE-ONTOLOGY

Class(es)

Kategorie

inheritable relation

einstellige Funktion

ListeLängeFn

Coordinate term(s)

AbsolutbetragFn AbstraktionFn ArcuskosinusFn ArcussinusFn ArcustangensFn RückseiteFn AnfangFn BeginNullPunktFn KardinalitätFn ObersteGrenzeFn ErgänzungFn KosinusFn SchnittMengeFn NennerFn EndeFn EndeNullPunktFn ExtensionFn UntersteGrenzeFn FrontseiteFn ZukunftFn GeneralisierteDurchschnittFn GeneralisierteVereinigungFn GigaFn ImaginäresTeilFn SofortigeZukunftFn DirektVergangenheitFn AusgangsNullPunktFn GanzzahlQuadratwurzelFn KiloFn GrösseFn MegaFn MicroFn MilliFn MinimaleSchnittMengeFn NanoFn ZählerFn OrganisationFn VergangenheitFn PfadGewichtfn PicoFn PotenzMengeFn VorgängerFn HauptwirtFn Wahrscheinlichkeit EigentumFn RationaleZahlFn ReelleZahlfn ReziprokerWert RundFn SignumFn SinusFn OberflächeFn QuadratwurzelFn NachfolgerFn TangensFn TeraFn TerminalNullPunktFn Füllefn WennFn JahrFn

Type restrictions

nichtnegative Ganzzahl ListLengthFn(Liste)

Axioms (7)

Wenn "Länge von list" ist gleich number1 , dann für jeden number2 gilt: es gibt ein item der "number2te mitglied von list" ist gleich item nur wenn number2 ist kleinerAlsOderGleich number1 .

(=>
      (equal
            (ListLengthFn ?LIST)
            ?NUMBER1)
      (forall
            (?NUMBER2)
            (<=>
                  (exists
                        (?ITEM)
                        (equal
                              (ListOrderFn ?LIST ?NUMBER2)
                              ?ITEM))
                  (lessThanOrEqualTo ?NUMBER2 ?NUMBER1))))

"Länge von "(,item)"" ist gleich "("Länge von "()""+1)" .

(equal
      (ListLengthFn
            (ListFn @ROW ?ITEM))
      (SuccessorFn
            (ListLengthFn
                  (ListFn @ROW))))

""Länge von "(,item)""te mitglied von "(,item)"" ist gleich item .

(equal
      (ListOrderFn
            (ListFn @ROW ?ITEM)
            (ListLengthFn
                  (ListFn @ROW ?ITEM)))
      ?ITEM)

wenn rel hat number argument(e),
dann für jeden gilt: wenn rel() gilt , dann "Länge von "()"" ist gleich number

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

Wenn "Länge von list1" ist gleich number , dann es gibt ein list2 der list1 beginnt list2 und "(number+1)" ist gleich "Länge von list2" und ""(number+1)"te mitglied von list2" ist gleich item .

(=>
      (equal
            (ListLengthFn ?LIST1)
            ?NUMBER)
      (exists
            (?LIST2)
            (and
                  (initialList ?LIST1 ?LIST2)
                  (equal
                        (SuccessorFn ?NUMBER)
                        (ListLengthFn ?LIST2))
                  (equal
                        (ListOrderFn
                              ?LIST2
                              (SuccessorFn ?NUMBER))
                        ?ITEM))))

list3 ist gleich "die Liste bestanden aus list1 und list2" nur wenn für jeden number1,number2 gilt: wenn number1 ist kleinerAlsOderGleich "Länge von list1" und number2 ist kleinerAlsOderGleich "Länge von list2" und number1 ist ein fall von positive Ganzzahl und number2 ist ein fall von positive Ganzzahl , dann "number1te mitglied von list3" ist gleich "number1te mitglied von list1" und ""("Länge von list1"+number2)"te mitglied von list3" ist gleich "number2te mitglied von list2" .

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

wenn list1 beginnt list2 ,
dann für jeden number1,number2 gilt: wenn "Länge von list1" ist gleich number1 und number2 ist kleinerAlsOderGleich number1 , dann "number2te mitglied von list1" ist gleich "number2te mitglied von list2"

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