# Integer

An **integer** (from the Latin *integer* meaning "whole")^{[a]} is colloquially defined as a number that can be written without a fractional component. For example, 21, 4, 0, and −2048 are integers, while 9.75, 5+1/2, and √2 are not.

The integers form the smallest group and the smallest ring containing the natural numbers. In algebraic number theory, the integers are sometimes qualified as **rational integers** to distinguish them from the more general algebraic integers. In fact, (rational) integers are algebraic integers that are also rational numbers.

The following table lists some of the basic properties of addition and multiplication for any integers *a*, *b* and *c*:

The ordering of integers is compatible with the algebraic operations in the following way:

The integers are the only nontrivial totally ordered abelian group whose positive elements are well-ordered.^{[12]} This is equivalent to the statement that any Noetherian valuation ring is either a field—or a discrete valuation ring.

In elementary school teaching, integers are often intuitively defined as the (positive) natural numbers, zero, and the negations of the natural numbers. However, this style of definition leads to many different cases (each arithmetic operation needs to be defined on each combination of types of integer) and makes it tedious to prove that integers obey the various laws of arithmetic.^{[13]} Therefore, in modern set-theoretic mathematics, a more abstract construction^{[14]} allowing one to define arithmetical operations without any case distinction is often used instead.^{[15]} The integers can thus be formally constructed as the equivalence classes of ordered pairs of natural numbers (*a*,*b*).^{[16]}

The intuition is that (*a*,*b*) stands for the result of subtracting *b* from *a*.^{[16]} To confirm our expectation that 1 − 2 and 4 − 5 denote the same number, we define an equivalence relation ~ on these pairs with the following rule:

Addition and multiplication of integers can be defined in terms of the equivalent operations on the natural numbers;^{[16]} by using [(*a*,*b*)] to denote the equivalence class having (*a*,*b*) as a member, one has:

The negation (or additive inverse) of an integer is obtained by reversing the order of the pair:

Hence subtraction can be defined as the addition of the additive inverse:

It is easily verified that these definitions are independent of the choice of representatives of the equivalence classes.

Every equivalence class has a unique member that is of the form (*n*,0) or (0,*n*) (or both at once). The natural number *n* is identified with the class [(*n*,0)] (i.e., the natural numbers are embedded into the integers by map sending *n* to [(*n*,0)]), and the class [(0,*n*)] is denoted −*n* (this covers all remaining classes, and gives the class [(0,0)] a second time since −0 = 0.

If the natural numbers are identified with the corresponding integers (using the embedding mentioned above), this convention creates no ambiguity.

In theoretical computer science, other approaches for the construction of integers are used by automated theorem provers and term rewrite engines.
Integers are represented as algebraic terms built using a few basic operations (e.g., **zero**, **succ**, **pred**) and, possibly, using natural numbers, which are assumed to be already constructed (using, say, the Peano approach).

There exist at least ten such constructions of signed integers.^{[17]} These constructions differ in several ways: the number of basic operations used for the construction, the number (usually, between 0 and 2) and the types of arguments accepted by these operations; the presence or absence of natural numbers as arguments of some of these operations, and the fact that these operations are free constructors or not, i.e., that the same integer can be represented using only one or many algebraic terms.

An integer is often a primitive data type in computer languages. However, integer data types can only represent a subset of all integers, since practical computers are of finite capacity. Also, in the common two's complement representation, the inherent definition of sign distinguishes between "negative" and "non-negative" rather than "negative, positive, and 0". (It is, however, certainly possible for a computer to determine whether an integer value is truly positive.) Fixed length integer approximation data types (or subsets) are denoted *int* or Integer in several programming languages (such as Algol68, C, Java, Delphi, etc.).

Variable-length representations of integers, such as bignums, can store any integer that fits in the computer's memory. Other integer data types are implemented with a fixed size, usually a number of bits which is a power of 2 (4, 8, 16, etc.) or a memorable number of decimal digits (e.g., 9 or 10).

*This article incorporates material from Integer on PlanetMath, which is licensed under the Creative Commons Attribution/Share-Alike License.*