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

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

 class

inheritable relation

unary function

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

integer SuccessorFn(integer)

## Axioms (8)

"length of "(,item)"" is equal to "("length of "()""+1)".
```(equal
(ListLengthFn
(ListFn @ROW ?ITEM))
(SuccessorFn
(ListLengthFn
(ListFn @ROW))))```

If "length of list1" is equal to number, then there exists list2 so that list1 starts list2 and "(number+1)" is equal to "length of list2" and ""(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)

If "(int1+1)" is equal to "(int2+1)", then int1 is equal to int2.
```(=>
(equal
(SuccessorFn ?INT1)
(SuccessorFn ?INT2))
(equal ?INT1 ?INT2))```

If int is an instance of integer, then int is less than "(int+1)".
```(=>
(instance ?INT Integer)
(lessThan
?INT
(SuccessorFn ?INT)))```

If int1 is an instance of integer and int2 is an instance of integer, then int1 is not less than int2 or int2 is not less than "(int1+1)".
```(=>
(and
(instance ?INT1 Integer)
(instance ?INT2 Integer))
(not
(and
(lessThan ?INT1 ?INT2)
(lessThan
?INT2
(SuccessorFn ?INT1)))))```

If int is an instance of integer, then int is equal to "("(int+2)"+1)".
```(=>
(instance ?INT Integer)
(equal
?INT
(SuccessorFn
(PredecessorFn ?INT))))```

If int is an instance of integer, then int is equal to "("(int+1)"+2)".
```(=>
(instance ?INT Integer)
(equal
?INT
(PredecessorFn
(SuccessorFn ?INT))))```