what does isbn have to do with modular arithmetic

Computation modulo a fixed integer

Fourth dimension-keeping on this clock uses arithmetics modulo 12. Adding 4 hours to 9 o'clock gives 1 o'clock, since 13 is congruent to 1 modulo 12.

In mathematics, modular arithmetic is a system of arithmetic for integers, where numbers "wrap effectually" when reaching a sure value, called the modulus. The modern approach to modular arithmetics was adult past Carl Friedrich Gauss in his book Disquisitiones Arithmeticae, published in 1801.

A familiar use of modular arithmetic is in the 12-60 minutes clock, in which the day is divided into two 12-hour periods. If the time is 7:00 now, then viii hours later on information technology will be three:00. Simple add-on would result in vii + eight = 15, but clocks "wrap around" every 12 hours. Because the hour number starts over after information technology reaches 12, this is arithmetics modulo 12. In terms of the definition beneath, 15 is congruent to 3 modulo 12, so "15:00" on a 24-hr clock is displayed "3:00" on a 12-60 minutes clock.

Congruence [edit]

Given an integer $n > 1$ , called a modulus, two integers $a$ and $b$ are said to be coinciding modulo $north$ , if $n$ is a divisor of their difference (i.e., if at that place is an integer $one thousand$ such that $a - b = kn$ ).

Congruence modulo $n$ is a congruence relation, pregnant that information technology is an equivalence relation that is uniform with the operations of add-on, subtraction, and multiplication. Congruence modulo $n$ is denoted:

a\equiv b{\pmod {due north}}.

The parentheses hateful that $(mod n)$ applies to the entire equation, not only to the correct-hand side (here $b$ ). This note is not to be confused with the notation $b mod n$ (without parentheses), which refers to the modulo functioning. Indeed, $b mod due north$ denotes the unique integer $a$ such that $0 \leq a < n$ and $a\equiv b\;({\text{modernistic}}\;n)$ (i.e., the remainder of $b$ when divided past $northward$ ).

The congruence relation may be rewritten as

a=kn+b,

explicitly showing its relationship with Euclidean segmentation. Nevertheless, the $b$ here need not be the remainder of the segmentation of $a$ past $n .$ Instead, what the argument $a \equiv b (modern north)$ asserts is that $a$ and $b$ have the same residue when divided past $n$ . That is,

a=pn+r,

b=qn+r,

where $0 \leq r < n$ is the common rest. Subtracting these 2 expressions, we recover the previous relation:

a-b=kn,

by setting $k = p - q .$

Examples [edit]

In modulus 12, one can assert that:

38\equiv 14{\pmod {12}}

because $38 - 14 = 24$ , which is a multiple of 12. Another way to express this is to say that both 38 and 14 accept the same remainder ii, when divided by 12.

The definition of congruence as well applies to negative values. For example:

{\begin{aligned}2&\equiv -3{\pmod {5}}\\-8&\equiv seven{\pmod {v}}\\-3&\equiv -viii{\pmod {5}}.\end{aligned}}

Properties [edit]

The congruence relation satisfies all the conditions of an equivalence relation:

Reflexivity: $a \equiv a (modernistic n)$
Symmetry: $a \equiv b (mod north)$ if $b \equiv a (mod n)$ for all $a$ , $b$ , and $n$ .
Transitivity: If $a \equiv b (modernistic n)$ and $b \equiv c (modern due north)$ , then $a \equiv c (modernistic northward)$

If $a one \equiv b ane (mod n)$ and $a 2 \equiv b 2 (mod north),$ or if $a \equiv b (mod northward),$ then:^[1]

$a + k \equiv b + g (mod n)$ for any integer $k$ (compatibility with translation)
$1000 a \equiv g b (mod north)$ for whatsoever integer $thou$ (compatibility with scaling)
$a 1 + a 2 \equiv b 1 + b 2 (mod n)$ (compatibility with addition)
$a 1 - a 2 \equiv b 1 - b two (modern northward)$ (compatibility with subtraction)
$a i a 2 \equiv b i b 2 (mod n)$ (compatibility with multiplication)
$a k \equiv b yard (modernistic n)$ for whatever non-negative integer $k$ (compatibility with exponentiation)
$p (a) \equiv p (b) (modern n)$ , for any polynomial $p (x)$ with integer coefficients (compatibility with polynomial evaluation)

If $a \equiv b (modernistic due north)$ , then information technology is generally false that $grand a \equiv chiliad b (mod n)$ . However, the post-obit is truthful:

If $c \equiv d (modern φ (due north)),$ where $φ$ is Euler'due south totient part, then $a c \equiv a d (modern n)$ —provided that $a$ is coprime with $n$ .

For cancellation of mutual terms, nosotros have the following rules:

If $a + k \equiv b + k (mod northward)$ , where $yard$ is any integer, then $a \equiv b (modernistic n)$
If $k a \equiv m b (mod north)$ and $thousand$ is coprime with $due north$ , then $a \equiv b (mod due north)$
If $chiliad a \equiv k b (modern kn)$ , then $a \equiv b (mod n)$

The modular multiplicative inverse is defined by the following rules:

Being: there exists an integer denoted $a -ane$ such that $aa -1 \equiv 1 (mod n)$ if and only if $a$ is coprime with $n$ . This integer $a -one$ is called a modular multiplicative changed of $a$ modulo $n$ .
If $a \equiv b (modern n)$ and $a -1$ exists, so $a -ane \equiv b -one (mod northward)$ (compatibility with multiplicative inverse, and, if $a = b$ , uniqueness modulo $north$ )
If $a x \equiv b (mod n)$ and $a$ is coprime to $n$ , and so the solution to this linear congruence is given by $x \equiv a -1 b (mod northward)$

The multiplicative inverse $x \equiv a -1 (modern n)$ may be efficiently computed by solving Bézout's equation $ax+ny=1$ for $x,y$ —using the Extended Euclidean algorithm.

In item, if $p$ is a prime, then $a$ is coprime with $p$ for every $a$ such that $0 < a < p$ ; thus a multiplicative inverse exists for all $a$ that is not congruent to zero modulo $p$ .

Some of the more advanced backdrop of congruence relations are the following:

Fermat's little theorem: If $p$ is prime and does not carve up $a$ , and then $a p - 1 \equiv 1 (modern p)$ .
Euler'south theorem: If $a$ and $due north$ are coprime, then $a φ (due north) \equiv 1 (mod n)$ , where $φ$ is Euler's totient role
A elementary consequence of Fermat'southward niggling theorem is that if $p$ is prime, and so $a -one \equiv a p - 2 (modern p)$ is the multiplicative inverse of $0 < a < p$ . More generally, from Euler's theorem, if $a$ and $n$ are coprime, then $a -1 \equiv a φ (n) - ane (modernistic n)$ .
Another simple effect is that if $a \equiv b (mod φ (northward)),$ where $φ$ is Euler'south totient role, then $k a \equiv thousand b (mod n)$ provided $k$ is coprime with $northward$ .
Wilson's theorem: $p$ is prime if and only if $(p - i)! \equiv -1 (mod p)$ .
Chinese residual theorem: For any $a$ , $b$ and coprime $m$ , $n$ , there exists a unique $x (mod mn)$ such that $10 \equiv a (modernistic grand)$ and $10 \equiv b (modernistic n)$ . In fact, $10 \equiv b thou n -i m + a n grand -one n (mod mn)$ where $thousand n -i$ is the inverse of $m$ modulo $northward$ and $n thou -1$ is the inverse of $n$ modulo $m$ .
Lagrange's theorem: The congruence $f (10) \equiv 0 (modernistic p)$ , where $p$ is prime, and $f (10) = a 0 x northward + ... + a due north$ is a polynomial with integer coefficients such that $a 0 \neq 0 (mod p)$ , has at virtually $n$ roots.
Primitive root modulo $due north$ : A number $g$ is a primitive root modulo $n$ if, for every integer $a$ coprime to $n$ , there is an integer $yard$ such that $thousand k \equiv a (mod n)$ . A archaic root modulo $n$ exists if and simply if $north$ is equal to $two, four, p k$ or $2 p one thousand$ , where $p$ is an odd prime number and $thou$ is a positive integer. If a primitive root modulo $n$ exists, so there are exactly $φ (φ (n))$ such primitive roots, where $φ$ is the Euler'due south totient function.
Quadratic residue: An integer $a$ is a quadratic balance modulo $due north$ , if at that place exists an integer $x$ such that $102 \equiv a (modern n)$ . Euler's criterion asserts that, if $p$ is an odd prime, and $a$ is not a multiple of $p$ , then $a$ is a quadratic residue modulo $p$ if and simply if

a^{(p-1)/two}\equiv one{\pmod {p}}.

Congruence classes [edit]

Like any congruence relation, congruence modulo $n$ is an equivalence relation, and the equivalence class of the integer $a$ , denoted by $a northward$ , is the fix ${... , a - 2 due north, a - n, a, a + n, a + two northward, ...$ }. This ready, consisting of all the integers congruent to $a$ modulo $n$ , is chosen the congruence class, residue class, or simply rest of the integer $a$ modulo $n$ . When the modulus $n$ is known from the context, that rest may besides be denoted $[a]$ .

Residue systems [edit]

Each residue grade modulo $n$ may be represented by whatsoever one of its members, although we usually represent each residual class by the smallest nonnegative integer which belongs to that class^[2] (since this is the proper residue which results from partition). Any ii members of different residue classes modulo $due north$ are incongruent modulo $n$ . Furthermore, every integer belongs to one and only one residual class modulo $north$ .^[3]

The set of integers ${0, 1, two, ..., n - 1$ } is chosen the to the lowest degree rest system modulo $n$ . Any set of $n$ integers, no 2 of which are congruent modulo $n$ , is chosen a complete residue system modulo $due north$ .

The least residue system is a complete residuum organisation, and a complete residuum arrangement is simply a gear up containing precisely 1 representative of each remainder class modulo $n$ .^[4] For example. the least residue organization modulo 4 is {0, 1, two, 3}. Another complete residue systems modulo 4 include:

{1, 2, 3, 4}
{thirteen, xiv, fifteen, 16}
{−2, −1, 0, 1}
{−thirteen, iv, 17, 18}
{−five, 0, half dozen, 21}
{27, 32, 37, 42}

Some sets which are not consummate residue systems modulo four are:

{−5, 0, 6, 22}, since 6 is coinciding to 22 modulo four.
{five, 15}, since a complete residue system modulo 4 must have exactly iv incongruent residuum classes.

Reduced rest systems [edit]

Given the Euler's totient office $φ(due north)$ , whatsoever set of $φ(n)$ integers that are relatively prime number to $n$ and mutually incongruent under modulus $n$ is called a reduced residual system modulo $northward$ .^[5] The ready {5,fifteen} from above, for example, is an example of a reduced balance system modulo 4.

Integers modulo n [edit]

The gear up of all congruence classes of the integers for a modulus $north$ is called the ring of integers modulo $n$ ,^[6] and is denoted ${\textstyle \mathbb {Z} /n\mathbb {Z} }$ , $\mathbb {Z} /due north$ , or $\mathbb {Z} _{n}$ .^[7] The notation $\mathbb {Z} _{due north}$ is, even so, not recommended considering it tin can be confused with the set up of $north$ -adic integers. The ring $\mathbb {Z} /n\mathbb {Z}$ is primal to various branches of mathematics (see § Applications beneath).

The gear up is defined for n > 0 every bit:

\mathbb {Z} /n\mathbb {Z} =\left\{{\overline {a}}_{n}\mid a\in \mathbb {Z} \right\}=\left\{{\overline {0}}_{northward},{\overline {1}}_{northward},{\overline {2}}_{due north},\ldots ,{\overline {n{-}1}}_{north}\correct\}.

(When $due north = 0$ , $\mathbb {Z} /n\mathbb {Z}$ is not an empty set; rather, information technology is isomorphic to $\mathbb {Z}$ , since $a 0 = {a$ }.)

We ascertain improver, subtraction, and multiplication on $\mathbb {Z} /north\mathbb {Z}$ by the following rules:

The verification that this is a proper definition uses the properties given earlier.

In this way, $\mathbb {Z} /northward\mathbb {Z}$ becomes a commutative band. For case, in the ring $\mathbb {Z} /24\mathbb {Z}$ , we have

{\overline {12}}_{24}+{\overline {21}}_{24}={\overline {33}}_{24}={\overline {9}}_{24}

as in the arithmetics for the 24-hour clock.

We apply the notation $\mathbb {Z} /due north\mathbb {Z}$ because this is the caliber ring of $\mathbb {Z}$ by the ideal $due north\mathbb {Z}$ , a set containing all integers divisible by $n$ , where $0\mathbb {Z}$ is the singleton set ${0$ }. Thus $\mathbb {Z} /n\mathbb {Z}$ is a field when $n\mathbb {Z}$ is a maximal ideal (i.e., when $n$ is prime).

This can also exist constructed from the group $\mathbb {Z}$ under the addition operation solitary. The remainder class $a n$ is the group coset of $a$ in the quotient group $\mathbb {Z} /n\mathbb {Z}$ , a cyclic grouping.^[8]

Rather than excluding the special instance $northward = 0$ , it is more than useful to include $\mathbb {Z} /0\mathbb {Z}$ (which, as mentioned before, is isomorphic to the ring $\mathbb {Z}$ of integers). In fact, this inclusion is useful when discussing the characteristic of a ring.

The ring of integers modulo $due north$ is a finite field if and only if $due north$ is prime number (this ensures that every nonzero element has a multiplicative changed). If $north=p^{k}$ is a prime number power with k > 1, there exists a unique (up to isomorphism) finite field $\mathrm {GF} (due north)=\mathbb {F} _{n}$ with $northward$ elements, merely this is not $\mathbb {Z} /n\mathbb {Z}$ , which fails to exist a field considering it has zero-divisors.

The multiplicative subgroup of integers modulo north is denoted past $(\mathbb {Z} /n\mathbb {Z} )^{\times }$ . This consists of ${\overline {a}}_{north}$ (where a is coprime to n), which are precisely the classes possessing a multiplicative changed. This forms a commutative group under multiplication, with order $\varphi (n)$ .

Applications [edit]

In theoretical mathematics, modular arithmetics is ane of the foundations of number theory, touching on almost every aspect of its study, and it is also used extensively in group theory, ring theory, knot theory, and abstract algebra. In applied mathematics, information technology is used in computer algebra, cryptography, computer science, chemistry and the visual and musical arts.

A very applied application is to calculate checksums inside serial number identifiers. For example, International Standard Volume Number (ISBN) uses modulo 11 (for x digit ISBN) or modulo 10 (for 13 digit ISBN) arithmetic for fault detection. Likewise, International Bank Account Numbers (IBANs), for example, brand use of modulo 97 arithmetic to spot user input errors in bank account numbers. In chemical science, the last digit of the CAS registry number (a unique identifying number for each chemical compound) is a check digit, which is calculated by taking the last digit of the kickoff two parts of the CAS registry number times 1, the previous digit times two, the previous digit times 3 etc., adding all these up and computing the sum modulo 10.

In cryptography, modular arithmetic directly underpins public key systems such every bit RSA and Diffie–Hellman, and provides finite fields which underlie elliptic curves, and is used in a multifariousness of symmetric key algorithms including Avant-garde Encryption Standard (AES), International Information Encryption Algorithm (IDEA), and RC4. RSA and Diffie–Hellman use modular exponentiation.

In calculator algebra, modular arithmetic is commonly used to limit the size of integer coefficients in intermediate calculations and data. It is used in polynomial factorization, a problem for which all known efficient algorithms use modular arithmetic. Information technology is used past the well-nigh efficient implementations of polynomial greatest common divisor, verbal linear algebra and Gröbner basis algorithms over the integers and the rational numbers. As posted on Fidonet in the 1980s and archived at Rosetta Code, modular arithmetics was used to disprove Euler'due south sum of powers conjecture on a Sinclair QL microcomputer using just one-fourth of the integer precision used by a CDC 6600 supercomputer to disprove it ii decades earlier via a beast force search.^[nine]

In figurer science, modular arithmetic is often applied in bitwise operations and other operations involving fixed-width, cyclic data structures. The modulo operation, equally implemented in many programming languages and calculators, is an application of modular arithmetics that is often used in this context. The logical operator XOR sums 2 bits, modulo ii.

In music, arithmetic modulo 12 is used in the consideration of the system of twelve-tone equal temperament, where octave and enharmonic equivalency occurs (that is, pitches in a 1:ii or 2:1 ratio are equivalent, and C-sharp is considered the same as D-flat).

The method of casting out nines offers a quick check of decimal arithmetics computations performed by hand. It is based on modular arithmetic modulo nine, and specifically on the crucial property that x ≡ 1 (mod 9).

Arithmetics modulo 7 is used in algorithms that determine the day of the calendar week for a given engagement. In particular, Zeller'southward congruence and the Doomsday algorithm make heavy use of modulo-7 arithmetic.

More than by and large, modular arithmetic as well has application in disciplines such as law (east.g., apportionment), economics (e.g., game theory) and other areas of the social sciences, where proportional sectionalization and allocation of resource plays a central office of the analysis.

Computational complexity [edit]

Since modular arithmetics has such a wide range of applications, information technology is important to know how hard it is to solve a organization of congruences. A linear system of congruences can be solved in polynomial time with a form of Gaussian elimination, for details run across linear congruence theorem. Algorithms, such as Montgomery reduction, also be to let elementary arithmetic operations, such as multiplication and exponentiation modulo $n$ , to be performed efficiently on large numbers.

Some operations, like finding a discrete logarithm or a quadratic congruence appear to be as hard equally integer factorization and thus are a starting signal for cryptographic algorithms and encryption. These issues might be NP-intermediate.

Solving a system of non-linear modular arithmetic equations is NP-consummate.^[10]

Instance implementations [edit]

Beneath are three reasonably fast C functions, two for performing modular multiplication and one for modular exponentiation on unsigned integers not larger than 63 bits, without overflow of the transient operations.

An algorithmic way to compute $a\cdot b{\pmod {m}}$ :^[eleven]

                        uint64_t                                    mul_mod            (            uint64_t                                    a            ,                                    uint64_t                                    b            ,                                    uint64_t                                    k            )                                    {                                                if                                    (            !            ((            a                                    |                                    b            )                                    &                                    (            0xFFFFFFFFULL                                    <<                                    32            )))                                    return                                    a                                    *                                    b                                    %                                    g            ;                                                uint64_t                                    d                                    =                                    0            ,                                    mp2                                    =                                    m                                    >>                                    1            ;                                                int                                    i            ;                                                if                                    (            a                                    >=                                    m            )                                    a                                    %=                                    m            ;                                                if                                    (            b                                    >=                                    m            )                                    b                                    %=                                    m            ;                                                for                                    (            i                                    =                                    0            ;                                    i                                    <                                    64            ;                                    ++            i            )                                    {                                                d                                    =                                    (            d                                    >                                    mp2            )                                    ?                                    (            d                                    <<                                    i            )                                    -                                    chiliad            :                                    d                                    <<                                    1            ;                                                if                                    (            a                                    &                                    0x8000000000000000ULL            )                                    d                                    +=                                    b            ;                                                if                                    (            d                                    >=                                    k            )                                    d                                    -=                                    m            ;                                                a                                    <<=                                    1            ;                                                }                                                return                                    d            ;                        }

On computer architectures where an extended precision format with at least 64 bits of mantissa is available (such as the long double blazon of most x86 C compilers), the following routine is^{[ description needed ]}, past employing the trick that, past hardware, floating-indicate multiplication results in the most pregnant bits of the production kept, while integer multiplication results in the least pregnant $.25 kept:^{[ commendation needed ]}

                        uint64_t                                    mul_mod            (            uint64_t                                    a            ,                                    uint64_t                                    b            ,                                    uint64_t                                    one thousand            )                                    {                                                long                                    double                                    10            ;                                                uint64_t                                    c            ;                                                int64_t                                    r            ;                                                if                                    (            a                                    >=                                    thousand            )                                    a                                    %=                                    m            ;                                                if                                    (            b                                    >=                                    m            )                                    b                                    %=                                    g            ;                                                x                                    =                                    a            ;                                                c                                    =                                    10                                    *                                    b                                    /                                    thousand            ;                                                r                                    =                                    (            int64_t            )(            a                                    *                                    b                                    -                                    c                                    *                                    yard            )                                    %                                    (            int64_t            )            m            ;                                                return                                    r                                    <                                    0                                    ?                                    r                                    +                                    m            :                                    r            ;                        }

Beneath is a C function for performing modular exponentiation, that uses the $mul_mod$ function implemented above.

An algorithmic way to compute $a^{b}{\pmod {m}}$ :

                        uint64_t                                    pow_mod            (            uint64_t                                    a            ,                                    uint64_t                                    b            ,                                    uint64_t                                    m            )                                    {                                                uint64_t                                    r                                    =                                    m                                    ==                                    ane                                    ?                                    0                                    :                                    1            ;                                                while                                    (            b                                    >                                    0            )                                    {                                                if                                    (            b                                    &                                    1            )                                    r                                    =                                    mul_mod            (            r            ,                                    a            ,                                    m            );                                                b                                    =                                    b                                    >>                                    1            ;                                                a                                    =                                    mul_mod            (            a            ,                                    a            ,                                    m            );                                                }                                                render                                    r            ;                        }

However, for all above routines to work, $m$ must non exceed 63 bits.

Encounter likewise [edit]

Boolean ring
Round buffer
Partition (mathematics)
Finite field
Legendre symbol
Modular exponentiation
Modulo (mathematics)
Multiplicative group of integers modulo n
Pisano catamenia (Fibonacci sequences modulo n)
Archaic root modulo n
Quadratic reciprocity
Quadratic residue
Rational reconstruction (mathematics)
Reduced residue organization
Serial number arithmetic (a special instance of modular arithmetic)
Two-element Boolean algebra
Topics relating to the grouping theory backside modular arithmetic:
- Circadian group
- Multiplicative grouping of integers modulo n
Other important theorems relating to modular arithmetic:
- Carmichael's theorem
- Chinese remainder theorem
- Euler's theorem
- Fermat's piffling theorem (a special case of Euler'southward theorem)
- Lagrange'southward theorem
- Thue's lemma

Notes [edit]

^ Sandor Lehoczky; Richard Rusczky. David Patrick (ed.). the Art of Trouble Solving. Vol. 1 (7 ed.). p. 44. ISBN0977304566.
^ Weisstein, Eric West. "Modular Arithmetic". mathworld.wolfram.com . Retrieved 2020-08-12 .
^ Pettofrezzo & Byrkit (1970, p. 90)
^ Long (1972, p. 78)
^ Long (1972, p. 85)
^ It is a band, as shown below.
^ "2.3: Integers Modulo northward". Mathematics LibreTexts. 2013-11-sixteen. Retrieved 2020-08-12 .
^ Sengadir T., Discrete Mathematics and Combinatorics, p. 293, at Google Books
^ "Euler'due south sum of powers conjecture". rosettacode.org . Retrieved 2020-eleven-11 .
^ Garey, One thousand. R.; Johnson, D. Southward. (1979). Computers and Intractability, a Guide to the Theory of NP-Completeness . W. H. Freeman. ISBN0716710447.
^ This lawmaking uses the C literal note for unsigned long long hexadecimal numbers, which end with ULL. Run into also section 6.4.4 of the language specification n1570.

References [edit]

John L. Berggren. "modular arithmetic". Encyclopædia Britannica.
Apostol, Tom M. (1976), Introduction to analytic number theory, Undergraduate Texts in Mathematics, New York-Heidelberg: Springer-Verlag, ISBN978-0-387-90163-3, MR 0434929, Zbl 0335.10001 . Encounter in detail chapters 5 and 6 for a review of basic modular arithmetic.
Maarten Bullynck "Modular Arithmetic before C.F. Gauss. Systematisations and discussions on residual problems in 18th-century Germany"
Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Clifford Stein. Introduction to Algorithms, 2nd Edition. MIT Printing and McGraw-Hill, 2001. ISBN 0-262-03293-7. Section 31.3: Modular arithmetic, pp. 862–868.
Anthony Gioia, Number Theory, an Introduction Reprint (2001) Dover. ISBN 0-486-41449-3.
Long, Calvin T. (1972). Simple Introduction to Number Theory (second ed.). Lexington: D. C. Heath and Company. LCCN 77171950.
Pettofrezzo, Anthony J.; Byrkit, Donald R. (1970). Elements of Number Theory . Englewood Cliffs: Prentice Hall. LCCN 71081766.
Sengadir, T. (2009). Detached Mathematics and Combinatorics. Chennai, India: Pearson Education India. ISBN978-81-317-1405-8. OCLC 778356123.

External links [edit]

"Congruence", Encyclopedia of Mathematics, EMS Press, 2001 [1994]
In this modular art article, one tin learn more about applications of modular arithmetic in art.
An commodity on modular arithmetic on the GIMPS wiki
Modular Arithmetic and patterns in addition and multiplication tables

griffithromustry.blogspot.com

Source: https://en.wikipedia.org/wiki/Modular_arithmetic