Ganzzahl (Integer)

A negative or nonnegative whole number.

Ontology

SUMO / BASE-ONTOLOGY

Superclass(es)

Wesen

abstrakter Gegenstand

Eigenschaft

Zahl

reelle Zahl

rationale Zahl

Ganzzahl

Subclass(es)

gerade Ganzzahl ungerade Ganzzahl Hauptzahl nichtnegative Ganzzahl negative Ganzzahl

Constrains relations

ObersteGrenzeFn NennerFn ExponentiationFn UntersteGrenzeFn GrössteGemeinsamerTeilerFn KleinsteGemeinsameVielfacheFn ZählerFn VorgängerFn SignumFn NachfolgerFn JahrFn

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)

Ganzzahl wird vollständig in ungerade Ganzzahl,gerade Ganzzahl verteilt.

(partition Integer OddInteger EvenInteger)

Ganzzahl wird vollständig in negative Ganzzahl,nichtnegative Ganzzahl verteilt.

(partition Integer NegativeInteger NonnegativeInteger)

Wenn seq ist ein fall von Sequenzfunktion und bildbereich von seq ist ein fall von class {nicht}, dann class ist eine teilkategorie von Ganzzahl.

(=>
      (and
            (instance ?SEQ SequenceFunction)
            (range ?SEQ ?CLASS))
      (subclass ?CLASS Integer))

Wenn number ist ein fall von rationale Zahl , dann es gibt ein Ganzzahl int1,Ganzzahl int2 der number ist gleich "int1/int2" .

(=>
      (instance ?NUMBER RationalNumber)
      (exists
            (?INT1 ?INT2)
            (and
                  (instance ?INT1 Integer)
                  (instance ?INT2 Integer)
                  (equal
                        ?NUMBER
                        (DivisionFn ?INT1 ?INT2)))))

Wenn "die oberstegrenze von number" ist gleich int , dann es gibt kein Ganzzahl otherint der otherint ist grösserAlsOderGleich number und otherint ist kleinerAls int .

(=>
      (equal
            (CeilingFn ?NUMBER)
            ?INT)
      (not
            (exists
                  (?OTHERINT)
                  (and
                        (instance ?OTHERINT Integer)
                        (greaterThanOrEqualTo ?OTHERINT ?NUMBER)
                        (lessThan ?OTHERINT ?INT)))))

Wenn "die grösste Ganzzahl kleiner als oder Gleichgestelltes zu number" ist gleich int , dann es gibt kein Ganzzahl otherint der otherint ist kleinerAlsOderGleich number und otherint ist grösserAls int .

(=>
      (equal
            (FloorFn ?NUMBER)
            ?INT)
      (not
            (exists
                  (?OTHERINT)
                  (and
                        (instance ?OTHERINT Integer)
                        (lessThanOrEqualTo ?OTHERINT ?NUMBER)
                        (greaterThan ?OTHERINT ?INT)))))

Wenn int ist ein fall von Ganzzahl , dann int ist kleinerAls "(int+1)" .

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

Wenn int1 ist ein fall von Ganzzahl und int2 ist ein fall von Ganzzahl , dann int1 ist kleinerAls int2 nicht oder int2 ist kleinerAls "(int1+1)" nicht.

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

Wenn int ist ein fall von Ganzzahl , dann int ist gleich "("(int+2)"+1)" .

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

Wenn int ist ein fall von Ganzzahl , dann int ist gleich "("(int+1)"+2)" .

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

Wenn int ist ein fall von Ganzzahl , dann int ist grösserAls "(int+2)" .

(=>
      (instance ?INT Integer)
      (greaterThan
            ?INT
            (PredecessorFn ?INT)))

Wenn int1 ist ein fall von Ganzzahl und int2 ist ein fall von Ganzzahl , dann int2 ist kleinerAls int1 nicht oder "(int1+2)" ist kleinerAls int2 nicht.

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