successor fn (SuccessorFn)

A UnaryFunction that maps an Integer to its successor, e.g. the successor of 5 is 6.

Ontology

SUMO / NUMERIC-FUNCTIONS

Class(es)

varga

inheritable relation

ekaadhaary prakaarya

successor fn

Coordinate term(s)

absolute value fn abstraction fn arc cosine fn arc sine fn arc tangent fn back fn begin fn begin node fn cardinality fn ceiling fn complement fn cosine fn cut set fn denominator fn end fn end node fn extension fn floor fn front fn future fn generalized intersection fn generalized union fn giga fn imaginary part fn immediate future fn immediate past fn initial node fn integer square root fn kilo fn list length fn magnitude fn mega fn micro fn milli fn minimal cut set fn nano fn numerator fn organization fn past fn path weight fn pico fn power set fn predecessor fn principal host fn probability fn property fn rational number fn real number fn reciprocal fn round fn signum fn sine fn skin fn square root fn tangent fn tera fn terminal node fn wealth fn when fn year fn

Type restrictions

pUrNaanka SuccessorFn(pUrNaanka)

Axioms (8)

""(,item)" kii lambaaaii" is equal to "(""()" kii lambaaaii"+1)".

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

Agar "list1 kii lambaaaii" is equal to number, to yah kuch list2 nahin, ki list1 starts list2 aur "(number+1)" is equal to "list2 kii lambaaaii" aur ""(number+1)"th element of list2" is equal to item.

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

"(number+1)" is equal to "(number+)".

(equal
      (SuccessorFn ?NUMBER)
      (AdditionFn ?NUMBER 1))

Agar "(int1+1)" is equal to "(int2+1)", to int1 is equal to int2.

(=>
      (equal
            (SuccessorFn ?INT1)
            (SuccessorFn ?INT2))
      (equal ?INT1 ?INT2))

Agar int is an instance of pUrNaanka, to int is less than "(int+1)".

(=>
      (instance ?INT Integer)
      (lessThan
            ?INT
            (SuccessorFn ?INT)))

Agar int1 is an instance of pUrNaanka aur int2 is an instance of pUrNaanka, to int1 is not less than int2 yaa int2 is not less than "(int1+1)".

(=>
      (and
            (instance ?INT1 Integer)
            (instance ?INT2 Integer))
      (not
            (and
                  (lessThan ?INT1 ?INT2)
                  (lessThan
                        ?INT2
                        (SuccessorFn ?INT1)))))

Agar int is an instance of pUrNaanka, to int is equal to "("(int+2)"+1)".

(=>
      (instance ?INT Integer)
      (equal
            ?INT
            (SuccessorFn
                  (PredecessorFn ?INT))))

Agar int is an instance of pUrNaanka, to int is equal to "("(int+1)"+2)".

(=>
      (instance ?INT Integer)
      (equal
            ?INT
            (PredecessorFn
                  (SuccessorFn ?INT))))