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

integer (Integer)

A negative or nonnegative whole number.

Ontology

SUMO / BASE-ONTOLOGY

Superclass(es)

[tree]
entity
is subclass of
  abstract  
is subclass of
  quantity  
is subclass of
  number  
is subclass of
  real number  
is subclass of
  rational number  
is subclass of
  integer  

Subclass(es)

even integer  odd integer  prime number  nonnegative integer  negative integer 

Constrains relations

ceiling fn  denominator fn  exponentiation fn  floor fn  greatest common divisor fn  least common multiple fn  numerator fn  predecessor fn  signum fn  successor fn  year fn 

Related WordNet synsets

integer, whole number
any of the natural numbers (positive or negative) or zero
integer is kind of (all)...   integer is kind of...   kinds of integer...   kinds of integer (all)...  
See more related synsets on a separate page.

Axioms (12)

integer is exhaustively partitioned into odd integer,even integer. 
(partition Integer OddInteger EvenInteger)
integer is exhaustively partitioned into negative integer,nonnegative integer. 
(partition Integer NegativeInteger NonnegativeInteger)
If seq is an instance of sequence function and range of seq is an instance of class, then class is a subclass of integer. 
(=>
      (and
            (instance ?SEQ SequenceFunction)
            (range ?SEQ ?CLASS))
      (subclass ?CLASS Integer))
If number is an instance of rational number, then there exist integer int1,integer int2 so that number is equal to "int1/int2". 
(=>
      (instance ?NUMBER RationalNumber)
      (exists
            (?INT1 ?INT2)
            (and
                  (instance ?INT1 Integer)
                  (instance ?INT2 Integer)
                  (equal
                        ?NUMBER
                        (DivisionFn ?INT1 ?INT2)))))
If "the ceiling of number" is equal to int, then there doesn't exist integer otherint so that otherint is greater than or equal to number and otherint is less than int. 
(=>
      (equal
            (CeilingFn ?NUMBER)
            ?INT)
      (not
            (exists
                  (?OTHERINT)
                  (and
                        (instance ?OTHERINT Integer)
                        (greaterThanOrEqualTo ?OTHERINT ?NUMBER)
                        (lessThan ?OTHERINT ?INT)))))
If "the largest integer less than or equal to number" is equal to int, then there doesn't exist integer otherint so that otherint is less than or equal to number and otherint is greater than int. 
(=>
      (equal
            (FloorFn ?NUMBER)
            ?INT)
      (not
            (exists
                  (?OTHERINT)
                  (and
                        (instance ?OTHERINT Integer)
                        (lessThanOrEqualTo ?OTHERINT ?NUMBER)
                        (greaterThan ?OTHERINT ?INT)))))
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))))
If int is an instance of integer, then int is greater than "(int+2)". 
(=>
      (instance ?INT Integer)
      (greaterThan
            ?INT
            (PredecessorFn ?INT)))
If int1 is an instance of integer and int2 is an instance of integer, then int2 is not less than int1 or "(int1+2)" is not less than int2. 
(=>
      (and
            (instance ?INT1 Integer)
            (instance ?INT2 Integer))
      (not
            (and
                  (lessThan ?INT2 ?INT1)
                  (lessThan
                        (PredecessorFn ?INT1)
                        ?INT2))))