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

# 俱计 (Integer)

A negative or nonnegative whole number.

## Ontology

SUMO / BASE-ONTOLOGY

 龟砰

┾禜

计秖

龟计

Τ瞶计

俱计

## Constrains relations

ㄧ计  虫ㄧ计  计ㄧ计  ㄧ计  程そ计ㄧ计  程そ计ㄧ计  だㄧ计  玡计ㄧ计  タ璽腹ㄧ计  计ㄧ计  ㄧ计

## Related WordNet synsets

integer, whole number
any of the natural numbers (positive or negative) or zero

See more related synsets on a separate page.

## Axioms (12)

`(partition Integer OddInteger EvenInteger)`

`(partition Integer NegativeInteger NonnegativeInteger)`

If seq抖ㄧ计龟ㄒ and seq絛瞅class  龟ㄒ, then class俱计Ω贺摸.
```(=>
(and
(instance ?SEQ SequenceFunction)
(range ?SEQ ?CLASS))
(subclass ?CLASS Integer))```

If numberΤ瞶计龟ㄒ, then there exist 俱计 int1,俱计 int2 so that number 单 "int1/int2".
```(=>
(instance ?NUMBER RationalNumber)
(exists
(?INT1 ?INT2)
(and
(instance ?INT1 Integer)
(instance ?INT2 Integer)
(equal
?NUMBER
(DivisionFn ?INT1 ?INT2)))))```

If "number" 单 int, then there doesn't exist 俱计 otherint so that otherint ┪单 number and otherint  int.
```(=>
(equal
(CeilingFn ?NUMBER)
?INT)
(not
(exists
(?OTHERINT)
(and
(instance ?OTHERINT Integer)
(greaterThanOrEqualTo ?OTHERINT ?NUMBER)
(lessThan ?OTHERINT ?INT)))))```

If "程 俱计  ┪ 单 number" 单 int, then there doesn't exist 俱计 otherint so that otherint ┪单 number and otherint (ぃ)  int.
```(=>
(equal
(FloorFn ?NUMBER)
?INT)
(not
(exists
(?OTHERINT)
(and
(instance ?OTHERINT Integer)
(lessThanOrEqualTo ?OTHERINT ?NUMBER)
(greaterThan ?OTHERINT ?INT)))))```

If int俱计龟ㄒ, then int  "(int+1)".
```(=>
(instance ?INT Integer)
(lessThan
?INT
(SuccessorFn ?INT)))```

If int1俱计龟ㄒ and int2俱计龟ㄒ, then int1  int2 or int2  "(int1+1)".
```(=>
(and
(instance ?INT1 Integer)
(instance ?INT2 Integer))
(not
(and
(lessThan ?INT1 ?INT2)
(lessThan
?INT2
(SuccessorFn ?INT1)))))```

If int俱计龟ㄒ, then int 单 "("(int+2)"+1)".
```(=>
(instance ?INT Integer)
(equal
?INT
(SuccessorFn
(PredecessorFn ?INT))))```

If int俱计龟ㄒ, then int 单 "("(int+1)"+2)".
```(=>
(instance ?INT Integer)
(equal
?INT
(PredecessorFn
(SuccessorFn ?INT))))```

If int俱计龟ㄒ, then int (ぃ)  "(int+2)".
```(=>
(instance ?INT Integer)
(greaterThan
?INT
(PredecessorFn ?INT)))```

If int1俱计龟ㄒ and int2俱计龟ㄒ, then int2  int1 or "(int1+2)"  int2.
```(=>
(and
(instance ?INT1 Integer)
(instance ?INT2 Integer))
(not
(and
(lessThan ?INT2 ?INT1)
(lessThan
(PredecessorFn ?INT1)
?INT2))))```