Modular Arithmetic Calculator — Free Online Mod Calculator

How to Use the Modular Arithmetic Calculator

1. Select the operation: Choose from four modular operations using the dropdown. Addition computes (a + b) mod m, subtraction computes (a - b) mod m, multiplication computes (a x b) mod m, and power computes a^b mod m using efficient modular exponentiation.
2. Enter value a: Type the first integer operand. For exponentiation, this is the base. The value can be any integer including negative numbers — the calculator automatically reduces it modulo m.
3. Enter value b: Type the second integer operand. For exponentiation, this is the exponent (must be non-negative). For other operations, b can be any integer.
4. Enter the modulus (m): Type the positive integer modulus. All results will be in the range [0, m-1]. The modulus must be at least 1.

The result panel also shows the reduced values of a and b (their remainders mod m), the greatest common divisor of a and m, and the modular inverse of a modulo m if it exists. The default values (17, 5, 7) demonstrate a simple addition: (17 + 5) mod 7 = 22 mod 7 = 1.

Modular Arithmetic Formulas

Variables Explained

• a (First Operand): The first integer in the operation. For exponentiation, this is the base. Any integer is valid — the calculator reduces it modulo m internally.
• b (Second Operand/Exponent): The second integer. For exponentiation, b must be a non-negative integer (the exponent). For other operations, any integer works.
• m (Modulus): The positive integer that defines the arithmetic system. Results are always in [0, m-1]. Common moduli include primes (for cryptography), powers of 2 (for computing), 10 (for check digits), 12 (for clocks), and 7 (for days of the week).
• gcd(a, m): The greatest common divisor. If gcd(a, m) = 1, the modular inverse of a exists. If gcd(a, m) > 1, no modular inverse exists.

Step-by-Step Example

Calculate 7^13 mod 11:

1. Start with a = 7, b = 13, m = 11
2. Express 13 in binary: 13 = 1101 in base 2 (8 + 4 + 1)
3. Square-and-multiply: 7^1 mod 11 = 7, 7^2 mod 11 = 49 mod 11 = 5, 7^4 mod 11 = 5^2 mod 11 = 25 mod 11 = 3, 7^8 mod 11 = 3^2 mod 11 = 9
4. Combine: 7^13 = 7^8 x 7^4 x 7^1 = 9 x 3 x 7 = 189
5. 189 mod 11 = 189 - 17 x 11 = 189 - 187 = 2

By Fermat's Little Theorem, since 11 is prime, 7^10 mod 11 = 1. So 7^13 = 7^10 x 7^3 = 1 x 343, and 343 mod 11 = 2. Both methods confirm the answer.

Practical Examples

Example 1: Alex Determines the Day of the Week

Alex wants to know what day of the week it will be 200 days from a Wednesday. Using modular arithmetic with modulus 7 (days in a week), where Wednesday = 3:

• Current day: Wednesday = 3
• (3 + 200) mod 7 = 203 mod 7
• 203 / 7 = 29 remainder 0
• 203 mod 7 = 0 = Sunday

200 days from Wednesday is a Sunday. This is exactly how calendar applications calculate future dates. The modulo operation elegantly handles the cyclic nature of weeks without needing to count through all 200 days individually.

Example 2: Priya Validates an ISBN

Priya is writing a library system and needs to validate ISBN-10 numbers using check digits. For ISBN 0-306-40615-2, the validation uses modular arithmetic with modulus 11:

• Multiply each digit by its position: 0x1 + 3x2 + 0x3 + 6x4 + 4x5 + 0x6 + 6x7 + 1x8 + 5x9 + 2x10
• Sum: 0 + 6 + 0 + 24 + 20 + 0 + 42 + 8 + 45 + 20 = 165
• 165 mod 11 = 0 (since 165 = 15 x 11)
• Result is 0, so the ISBN is valid

If the remainder is not 0, the ISBN contains an error. This check digit system can detect any single-digit error and most transposition errors. Credit card numbers use a similar modular validation called the Luhn algorithm (mod 10).

Example 3: Carlos Implements Hash Table Indexing

Carlos is building a hash table with 13 slots to store student records. He uses student IDs as keys and the modulo operation to compute array indices:

• Student 10452: 10452 mod 13 = 10452 - 803 x 13 = 10452 - 10439 = 13, 13 mod 13 = 0 (slot 0)
• Student 20318: 20318 mod 13 = 20318 - 1563 x 13 = 20318 - 20319 = hmm, 1562 x 13 = 20306, so 20318 - 20306 = 12 (slot 12)
• Student 15677: 15677 mod 13 = 15677 - 1205 x 13 = 15677 - 15665 = 12 (collision with slot 12!)

Carlos encounters a collision — two keys mapping to the same slot. He resolves it using chaining or open addressing. Choosing a prime number for the table size (like 13) helps distribute keys more evenly. This modular hashing is used in every programming language's dictionary/map implementation.

Modular Arithmetic Quick Reference Table

Tips and Complete Guide

Fermat's Little Theorem

If p is a prime number and a is not divisible by p, then a^(p-1) mod p = 1. This powerful theorem simplifies many modular exponentiation problems. For example, to compute 7^100 mod 13: since 13 is prime, 7^12 mod 13 = 1. Then 100 = 12 x 8 + 4, so 7^100 = (7^12)^8 x 7^4 = 1^8 x 7^4 mod 13. Computing 7^4 = 2401, and 2401 mod 13 = 9 (since 2401 = 184 x 13 + 9). This theorem is also the basis for the Fermat primality test used in cryptography.

Chinese Remainder Theorem

The Chinese Remainder Theorem (CRT) states that if you know the remainders of an integer when divided by several pairwise coprime moduli, you can reconstruct the original number uniquely modulo the product of those moduli. For example, a number that is 2 mod 3, 3 mod 5, and 2 mod 7 is uniquely determined modulo 105 (= 3 x 5 x 7). CRT has practical applications in RSA decryption (speeding up computation by working with smaller moduli) and in ancient Chinese and Indian mathematics for solving systems of congruences.

Modular Arithmetic in Programming

Every programming language provides a modulo operator (usually %). However, languages differ in how they handle negative numbers: in C, C++, and Java, -7 % 3 = -1, while in Python, -7 % 3 = 2. The Python convention (result has the same sign as the divisor) matches the mathematical definition. To ensure non-negative results in any language, use ((a % m) + m) % m. Modulo is used extensively for circular buffers, hash tables, random number generators, and any situation where values need to cycle through a fixed range.

Applications in Cryptography

RSA encryption works as follows: choose two large primes p and q, compute n = pq, find e and d such that ed mod ((p-1)(q-1)) = 1. Encrypt message m as c = m^e mod n. Decrypt as m = c^d mod n. The security relies on the fact that factoring n into p and q is computationally infeasible for sufficiently large primes (2048+ bits). Diffie-Hellman key exchange uses g^a mod p (where p is prime and g is a generator) to establish shared secrets over insecure channels. All of these require efficient modular exponentiation.

Common Mistakes to Avoid

• Forgetting the modulus must be positive: The modulus m must be a positive integer. Negative moduli and zero moduli are undefined in standard modular arithmetic. Our calculator requires m greater than 0.
• Assuming negative mod results are valid: In pure mathematics, the result of a mod m is always in [0, m-1]. Some programming languages return negative remainders for negative dividends. Always normalize: ((a % m) + m) % m gives the correct non-negative result.
• Trying to divide in modular arithmetic: Division is not directly defined. Instead, multiply by the modular inverse: a/b mod m = a x b^(-1) mod m, but only when the inverse of b exists (when gcd(b, m) = 1). If gcd(b, m) > 1, the "division" is undefined.
• Confusing modular exponentiation with regular exponentiation: a^b mod m is NOT the same as (a mod m)^b for large b — intermediate values overflow. Use the square-and-multiply algorithm to keep numbers manageable throughout the computation.
• Using non-prime moduli when primality is required: Fermat's Little Theorem and many cryptographic algorithms require a prime modulus. Using a composite modulus in these contexts gives incorrect results. Always verify that your modulus is prime when using theorems that assume primality.

Frequently Asked Questions