# Modular arithmetic

In mathematics,**modular arithmetic**is a system of arithmetic for certain equivalence classes of integers, called

**congruence classes**. Sometimes it is suggestively called 'clock arithmetic', where numbers 'wrap around' after they reach a certain value (the

**modulus**). For example, when the modulus is 12, then any two numbers that leave the same remainder when divided by 12 are equivalent (or "congruent") to each other. The numbers

- ..., −34, −22, −10, 2, 14, 26, ...

As explained below, one can add such congruence classes to get another such congruence class, subtract two such classes to get another, and multiply such classes to get another. When the modulus is a prime number, one can always divide by any class not containing 0.

## Definition of *modulo*

Two discrepant conventions prevail:

- the one originally introduced by Gauss two centuries ago, still used by mathematicians, and suitable for theoretical mathematics, and
- a newer one adhered to by computer scientists and perhaps more suitable for computing.

### The older convention, used by mathematicians

The original convention is that the expression

*a*and

*b*are both in the same "congruence class" modulo

*n*, i.e., both leave the same remainder on division by

*n*, or, equivalently,

*a*−

*b*is a multiple of

*n*. Thus we have, for example

- "63 is congruent to 83, modulo 10,"

- "63 and 83 are congruent to each other, modulo 10."

In Latin, the language in which Gauss wrote, *modulo* is the ablative case of *modulus*. The number *n*, which in this example is 10, is the **modulus**.

### The newer convention, used in computing

The difference in conventions is not very serious, in fact; it is reasonably thought of as reflecting the preference, for computational purposes, of a normal form over the underlying equivalence relation. This can be regarded mainly as a notational convention in this case, where there is a strict-sense normal form.

### Implementation of modulo in computing

Some calculators have a mod() function button, and many programming languages have a mod() function or similar, expressed as mod(*a*,*n*), for example. Some also support expressions that use "%" as a modulo operator, such as *a* % *n*.

*a* mod *n* can be calculated by using equations, in terms of other functions. Differences may arise according to the scope of the variables, which in common implementations is broader than in the definition just given.

An implementation of a modulo function that constrains the remainder set in the manner described above, as is found in the programming languages Perl and Python, can be described in terms of the floor function floor(*z*), the greatest integer less than or equal to *z*:

- mod(
*a*,*n*) =*a*−*n*× floor(*a*÷*n*)

*a*and

*n*to be typed as integers or rational numbers.

The expression *a* mod 0 is undefined in the majority of numerical systems, although some do define it to be *n*.

## Applications of modular arithmetic

Modular arithmetic, first systematically studied by Carl Friedrich Gauss at the end of the eighteenth century, is applied in number theory, abstract algebra, cryptography, and visual and musical art.

The fundamental arithmetic operations performed by most computers are actually modular arithmetic, where the modulus is 2^{b} (*b* being the number of bits of the values being operated on). This comes to light in the compilation programming languages such as C; where for example arithmetic operations on "int" integers are all taken modulo 2^{32}, on most computers.

### In art

In music, because of octave and enharmonic equivalency (that is, pitches in a 1/2 or 2/1 ratio are equivalent, and C# is the same as Db), modular arithmetic is used in the consideration of the twelve tone equally tempered scale, especially in twelve tone music. In visual art modular arithmetic can be used to create artistic patterns based on the multiplication and addition tables modulo *n* (see link below).

## Some consequences of the mathematical usage

Recall from above that two integers *a*, *b* **congruent modulo n**, written as

*a*≡*b*(**mod***n*) if their difference*a*−*b*is divisible by*n*, i.e. if*a*−*b*=*kn*for some integer*k*.

*a*≡

*b*(

**mod**π) if

*a*−

*b*=

*k*π for some integer

*k*. This idea is developed in full in the context of ring theory below.

Here is an example of the congruence notation.

- 14 ≡ 26 (
**mod**12).

*a*is denoted by [

*a*]

_{n}(or simply [

*a*] if the modulus

*n*is understood.) Other notations include

*a*+

*n*

**Z**or

*a*mod

*n*. The set of all equivalence classes is denoted

**Z**/

*n*

**Z**= { [0]

_{n}, [1]

_{n}, [2]

_{n}, ..., [

*n*-1]

_{n}}.

If *a* and *b* are integers, the congruence

*ax*≡*b*(**mod***n*)

*x*if and only if the greatest common divisor (

*a*,

*n*) divides

*b*. The details are recorded in the linear congruence theorem. More complicated simultaneous systems of congruences with different moduli can be solved using the Chinese remainder theorem or the method of successive substitution.

This equivalence relation has important properties which follow immediately from the definition: if

*a*_{1}≡*b*_{1}(**mod***n*) and*a*_{2}≡*b*_{2}(**mod***n*)

*a*_{1}+*a*_{2}≡*b*_{1}+*b*_{2}(**mod***n*)

*a*_{1}*a*_{2}≡*b*_{1}*b*_{2}(**mod***n*).

**Z**/

*n*

**Z**by the following formulae:

- [
*a*]_{n}+ [*b*]_{n}= [*a*+*b*]_{n} - [
*a*]_{n}[*b*]_{n}= [*ab*]_{n}

**Z**/

*n*

**Z**becomes a commutative ring with

*n*elements. For instance, in the ring

**Z**/12

**Z**, we have

- [8]
_{12}[3]_{12}+ [6]_{12}= [30]_{12}= [6]_{12}.

*R*is a commutative ring, and

*I*is an ideal of

*R*, then the elements

*a*and

*b*of

*R*are

**congruent modulo**if

*I**a*−

*b*is an element of

*I*. As with the ring of integers, this turns out to be an equivalence relation, and addition and multiplication become well-defined operations on the factor ring

*R*/

*I*.

In the ring of integers, if we consider the equation *ax* ≡ 1 (**mod** *n*), then we see that *a* has a multiplication inverse if and only if *a* and *n* are coprime. Therefore,
**Z**/*n***Z** is a field if and only if *n* is prime. It can be shown that every finite field is an extension of **Z**/*p***Z** for some prime *p*.

An important fact about prime number moduli is Fermat's little theorem: if *p* is a prime number and *a* is any integer, then

*a*≡^{p}*a*(**mod***p*).

*n*and any integer

*a*that is relatively prime to

*n*,

*a*^{φ(n)}≡ 1 (**mod***n*),

*n*) denotes Euler's φ function counting the integers between 1 and

*n*that are coprime to

*n*. Euler's theorem is a consequence of the Theorem of Lagrange, applied to the group of units of the ring

**Z**/

*n*

**Z**.

## Another "computing" usage

Digital representations of number spaces are not infinite (see binary numeral systems). Thus, if a computer is representing a set of positive integers as 8-bits, the values that can be represented range from 0 to 255. When an addition (or multiplication, or whatever) results in a number above this cutoff, the typical behavior is for the values to wrap around. For example, in the 8-bit positive integer situation, 255 + 1 = 0. This computer is therefore described as "modulo 256". Furthermore, some computers do different operations with different bit representations. So although the storage of integers may be 8-bit ("modulo 256"), the addition of integers may be 12-bit ("modulo 4096"), or anything else. Thus individual operations can also be described as "modulo *x*".

In the case of signed (positive and negative) integers, or floating point numbers, the wrap around effect is more complicated, and is not always perfectly analogous to the formal mathematical modulo. However, the slang persists such that "addition is modulo 1000" may not literally mean (in fact cannot literally mean) that the computer does addition in bits, but may simply mean "watch out: if you go over 1000 this computer will give you weird results".

## More general use of the word *modulo* by mathematicians

To say that any two things are the same "modulo" a third thing means, more-or-less, that the difference between the first two is accounted for or explained by the third. That is, the *up to* concept is often talked about this way, using *modulo* as a term alerting the hearer. In mathematics, this admits various precise definitions. In particular, two members of a ring or an algebra are congruent modulo an ideal if the difference between them is in the ideal. The use of the term in modular arithmetic is a special case of that usage, and that is how this more general usage evolved. Some loose terms such as *almost all* can in this way acquire precise meanings from a Boolean algebra version, in which symmetric difference of sets replaced arithmetical subtraction; for example "*modulo* finite sets".

See modulo.

## Slang use of the word *modulo*

### Examples

- "http and https are the same, modulo encryption." - means "the only difference between http and https is the addition of encryption".
- "These two characters are equal."
- "You mean, equal modulo case." - indicates that the first speaker is wrong: the characters are not the same, one is uppercase and the other lowercase.
- "The two students performed equally well on the exam, modulo some minor computational mistakes." - means that the two students demonstrated an equal understanding of the material and its application, but one of them lost some points for minor computational mistakes.
- "This code is finished modulo testing" - means "this code is finished except for testing". Since testing is generally considered quite important, whereas in mathematics the use of modular arithmetic generally ignores the difference between modulo-equal numbers, use of a phrase like this might be deliberate understatement.

## External resources

- Perl arithmetic enhancements -- explains the reasoning behind Perl's
*%*operator - Cut-the-Knot.org: Modular Arithmetic
- Modular Art