−1

Algebraic properties

Multiplying a number by −1 is equivalent to changing the sign of the number – that is, for any x we have (−1) ⋅ x = −x. This can be proved using the distributive law and the axiom that 1 is the multiplicative identity:

x + (−1) ⋅ x = 1 ⋅ x + (−1) ⋅ x = (1 + (−1)) ⋅ x = 0 ⋅ x = 0.

Here we have used the fact that any number x times 0 equals 0, which follows by cancellation from the equation

0 ⋅ x = (0 + 0) ⋅ x = 0 ⋅ x + 0 ⋅ x.

In other words,

x + (−1) ⋅ x = 0,

so (−1) ⋅ x is the additive inverse of x, i.e. (−1) ⋅ x = −x, as was to be shown.

The square of −1 (that is −1 multiplied by −1) equals 1. As a consequence, a product of two negative numbers is positive. For an algebraic proof of this result, start with the equation

0 = −1 ⋅ 0 = −1 ⋅ [1 + (−1)].

The first equality follows from the above result, and the second follows from the definition of −1 as additive inverse of 1: it is precisely that number which when added to 1 gives 0. Now, using the distributive law, it can be seen that

0 = −1 ⋅ [1 + (−1)] = −1 ⋅ 1 + (−1) ⋅ (−1) = −1 + (−1) ⋅ (−1).

The third equality follows from the fact that 1 is a multiplicative identity. But now adding 1 to both sides of this last equation implies

(−1) ⋅ (−1) = 1.

The above arguments hold in any ring, a concept of abstract algebra generalizing integers and real numbers.^: p.48

Although there are no real number square roots of −1, the complex number i satisfies i² = −1, and as such can be considered as a square root of −1. The only other complex number whose square is −1 is −i because there are exactly two square roots of any non‐zero complex number, which follows from the fundamental theorem of algebra. In the algebra of quaternions – where the fundamental theorem does not apply – which contains the complex numbers, the equation x² = −1 has infinitely many solutions.

Inverse and invertible elements

Exponentiation of a non‐zero real number can be extended to negative integers, where raising a number to the power −1 has the same effect as taking its multiplicative inverse:

x⁻¹ = ⁠1/x⁠.

This definition is then applied to negative integers, preserving the exponential law x^ax^b = x^{(a + b)} for real numbers a and b.

A −1 superscript in f ⁻¹(x) takes the inverse function of f(x), where (f(x))⁻¹ specifically denotes a pointwise reciprocal. Where f is bijective specifying an output codomain of every y ∈ Y from every input domain x ∈ X, there will be

f⁻¹(f(x)) = x, and f⁻¹(f(y)) = y.

When a subset of the codomain is specified inside the function f, its inverse will yield an inverse image, or preimage, of that subset under the function.

Exponentiation to negative integers can be further extended to invertible elements of a ring by defining x⁻¹ as the multiplicative inverse of x; in this context, these elements are considered units.^: p.49

In a polynomial domain F [x] over any field F, the polynomial x has no inverse. If it did have an inverse q(x), then there would be

x q(x) = 1 ⇒ deg(x) + deg(q(x)) = deg(1)

                 ⇒ 1 + deg(q(x)) = 0

                 ⇒ deg(q(x)) = −1

which is not possible, and therefore, F [x] is not a field. More specifically, because the polynomial is not constant, it is not a unit in F.

Sentinel values

The integer −1 is frequently used as a sentinel value to indicate the absence of a valid result. For example, the indexOf() method in Java and JavaScript returns −1 when a specified element or substring cannot be found. Similarly, Python's str.find() method returns −1 when a substring is absent.

Error signalling

In the C programming language and Unix-like operating systems, −1 is commonly used as a return value to indicate that a system call or library function has failed. For example, the open(), read() and write() system calls return −1 when an error occurs. Additional information about the error is generally provided through the errno variable, which identifies the particular error condition.

End-of-input signalling

In C++, the special constant EOF (end-of-file) is used to indicate that an input stream has reached its end or that an input operation has encountered an error. It is a negative integer constant, typically defined as −1, allowing it to be distinguished from valid character values, which are non-negative when represented as an unsigned char.

Unsigned integer arithmetic

In programming languages such as C and C++, converting the integer −1 to an unsigned integer type produces the maximum representable value of that type. This follows from the rules governing conversion to unsigned integer types, whereby the resulting value is obtained modulo one greater than the maximum representable value.

For an unsigned integer type capable of representing values from ${\displaystyle 0}$ to ${\displaystyle (2^{n}-1)}$, the conversion therefore produces:

${\displaystyle -1\equiv 2^{n}-1{\pmod {2^{n}}}.}$

For example, converting −1 to a 32-bit unsigned integer produces 4,294,967,295, while conversion to a 64-bit unsigned integer produces 18,446,744,073,709,551,615.

Notes

Sources