Modular division is the process of dividing one number by another in modular arithmetic. In modular arithmetic, division is defined differently from regular arithmetic because there is no direct “division” operation. Instead, modular division involves multiplying by the modular multiplicative inverse of the divisor under a given modulus.
Given integers a, b, and m, the modular division a/b (mod m) is computed as:
a/b (mod m) = a · b-1 (mod m)
where b−1 is the modular multiplicative inverse of b under modulus m, satisfying:
b ⋅ b−1 (mod m) = 1
Examples:
Input : a = 8, b = 4, m = 5 Output : 2 Input : a = 8, b = 3, m = 5 Output : 1 Note that (1*3)%5 is same as 8%5 Input : a = 11, b = 4, m = 5 Output : 4 Note that (4*4)%5 is same as 11%5
The following articles are prerequisites for this.
Can we always do modular division?
The answer is “NO”. First of all, like ordinary arithmetic, division by 0 is not defined. For example, 4/0 is not allowed. In modular arithmetic, not only 4/0 is not allowed, but 4/12 under modulo 6 is also not allowed. The reason is, 12 is congruent to 0 when modulus is 6.
When is modular division defined?
Modular division is defined when the modular inverse of the divisor exists. The inverse of an integer ‘x’ is another integer ‘y’ such that (x*y) % m = 1 where m is the modulus.
When does inverse exist?
As we discussed, inverse a number ‘a’ exists under modulo ‘m’ if ‘a’ and ‘m’ are co-prime, i.e., GCD of them is 1.
How to find modular division?
The task is to compute a/b under modulo m. 1) First check if inverse of b under modulo m exists or not. a) If inverse doesn't exists (GCD of b and m is not 1), print "Division not defined" b) Else return "(inverse * a) % m"
C++ // C++ program to do modular division #include<iostream> using namespace std; // C++ function for extended Euclidean Algorithm int gcdExtended(int a, int b, int *x, int *y); // Function to find modulo inverse of b. It returns // -1 when inverse doesn't int modInverse(int b, int m) { int x, y; // used in extended GCD algorithm int g = gcdExtended(b, m, &x, &y); // Return -1 if b and m are not co-prime if (g != 1) return -1; // m is added to handle negative x return (x%m + m) % m; } // Function to compute a/b under modulo m void modDivide(int a, int b, int m) { a = a % m; int inv = modInverse(b, m); if (inv == -1) cout << "Division not defined"; else cout << "Result of division is " << (inv * a) % m; } // C function for extended Euclidean Algorithm (used to // find modular inverse. int gcdExtended(int a, int b, int *x, int *y) { // Base Case if (a == 0) { *x = 0, *y = 1; return b; } int x1, y1; // To store results of recursive call int gcd = gcdExtended(b%a, a, &x1, &y1); // Update x and y using results of recursive // call *x = y1 - (b/a) * x1; *y = x1; return gcd; } // Driver Program int main() { int a = 8, b = 3, m = 5; modDivide(a, b, m); return 0; } //this code is contributed by khushboogoyal499 // C program to do modular division #include <stdio.h> // C function for extended Euclidean Algorithm int gcdExtended(int a, int b, int *x, int *y); // Function to find modulo inverse of b. It returns // -1 when inverse doesn't int modInverse(int b, int m) { int x, y; // used in extended GCD algorithm int g = gcdExtended(b, m, &x, &y); // Return -1 if b and m are not co-prime if (g != 1) return -1; // m is added to handle negative x return (x%m + m) % m; } // Function to compute a/b under modulo m void modDivide(int a, int b, int m) { a = a % m; int inv = modInverse(b, m); if (inv == -1) printf ("Division not defined"); else { int c = (inv * a) % m ; printf ("Result of division is %d", c) ; } } // C function for extended Euclidean Algorithm (used to // find modular inverse. int gcdExtended(int a, int b, int *x, int *y) { // Base Case if (a == 0) { *x = 0, *y = 1; return b; } int x1, y1; // To store results of recursive call int gcd = gcdExtended(b%a, a, &x1, &y1); // Update x and y using results of recursive // call *x = y1 - (b/a) * x1; *y = x1; return gcd; } // Driver Program int main() { int a = 8, b = 3, m = 5; modDivide(a, b, m); return 0; } // java program to do modular division import java.io.*; import java.lang.Math; public class GFG { static int gcd(int a,int b){ if (b == 0){ return a; } return gcd(b, a % b); } // Function to find modulo inverse of b. It returns // -1 when inverse doesn't // modInverse works for prime m static int modInverse(int b,int m){ int g = gcd(b, m) ; if (g != 1) return -1; else { //If b and m are relatively prime, //then modulo inverse is b^(m-2) mode m return (int)Math.pow(b, m - 2) % m; } } // Function to compute a/b under modulo m static void modDivide(int a,int b,int m){ a = a % m; int inv = modInverse(b,m); if(inv == -1){ System.out.println("Division not defined"); } else{ System.out.println("Result of Division is " + ((inv*a) % m)); } } // Driver Program public static void main(String[] args) { int a = 8; int b = 3; int m = 5; modDivide(a, b, m); } } // The code is contributed by Gautam goel (gautamgoel962) # Python3 program to do modular division import math # Function to find modulo inverse of b. It returns # -1 when inverse doesn't # modInverse works for prime m def modInverse(b,m): g = math.gcd(b, m) if (g != 1): # print("Inverse doesn't exist") return -1 else: # If b and m are relatively prime, # then modulo inverse is b^(m-2) mode m return pow(b, m - 2, m) # Function to compute a/b under modulo m def modDivide(a,b,m): a = a % m inv = modInverse(b,m) if(inv == -1): print("Division not defined") else: print("Result of Division is ",(inv*a) % m) # Driver Program a = 8 b = 3 m = 5 modDivide(a, b, m) # This code is Contributed by HarendraSingh22 using System; // C# program to do modular division class GFG { // Recursive Function to find // GCD of two numbers static int gcd(int a,int b){ if (b == 0){ return a; } return gcd(b, a % b); } // Function to find modulo inverse of b. It returns // -1 when inverse doesn't // modInverse works for prime m static int modInverse(int b,int m){ int g = gcd(b, m) ; if (g != 1){ return -1; } else { //If b and m are relatively prime, //then modulo inverse is b^(m-2) mode m return (int)Math.Pow(b, m - 2) % m; } } // Function to compute a/b under modulo m static void modDivide(int a,int b,int m){ a = a % m; int inv = modInverse(b,m); if(inv == -1){ Console.WriteLine("Division not defined"); } else{ Console.WriteLine("Result of Division is " + ((inv*a) % m)); } } // Driver Code static void Main() { int a = 8; int b = 3; int m = 5; modDivide(a, b, m); } } // The code is contributed by Gautam goel (gautamgoel962) <script> // JS program to do modular division function gcd(a, b) { if (b == 0) return a; return gcd(b, a % b); } // Function to find modulo inverse of b. It returns // -1 when inverse doesn't // modInverse works for prime m function modInverse(b,m) { g = gcd(b, m) ; if (g != 1) return -1; else { //If b and m are relatively prime, //then modulo inverse is b^(m-2) mode m return Math.pow(b, m - 2, m); } } // Function to compute a/b under modulo m function modDivide(a,b,m) { a = a % m; inv = modInverse(b,m); if(inv == -1) document.write("Division not defined"); else document.write("Result of Division is ",(inv*a) % m); } // Driver Program a = 8; b = 3; m = 5; modDivide(a, b, m); // This code is Contributed by phasing17 </script> <?php // PHP program to do modular division // Function to find modulo inverse of b. // It returns -1 when inverse doesn't function modInverse($b, $m) { $x = 0; $y = 0; // used in extended GCD algorithm $g = gcdExtended($b, $m, $x, $y); // Return -1 if b and m are not co-prime if ($g != 1) return -1; // m is added to handle negative x return ($x % $m + $m) % $m; } // Function to compute a/b under modulo m function modDivide($a, $b, $m) { $a = $a % $m; $inv = modInverse($b, $m); if ($inv == -1) echo "Division not defined"; else echo "Result of division is " . ($inv * $a) % $m; } // function for extended Euclidean Algorithm // (used to find modular inverse. function gcdExtended($a, $b, &$x, &$y) { // Base Case if ($a == 0) { $x = 0; $y = 1; return $b; } $x1 = 0; $y1 = 0; // To store results of recursive call $gcd = gcdExtended($b % $a, $a, $x1, $y1); // Update x and y using results of // recursive call $x = $y1 - (int)($b / $a) * $x1; $y = $x1; return $gcd; } // Driver Code $a = 8; $b = 3; $m = 5; modDivide($a, $b, $m); // This code is contributed by mits ?> Output:
Result of division is 1
Modular division is different from addition, subtraction and multiplication.
One difference is division doesn’t always exist (as discussed above). Following is another difference.
Below equations are valid (a * b) % m = ((a % m) * (b % m)) % m (a + b) % m = ((a % m) + (b % m)) % m // m is added to handle negative numbers (a - b + m) % m = ((a % m) - (b % m) + m) % m But, (a / b) % m may NOT be same as ((a % m)/(b % m)) % m For example, a = 10, b = 5, m = 5. (a / b) % m is 2, but ((a % m) / (b % m)) % m is not defined.
Similar Reads
Modular Arithmetic
Modular arithmetic is a system of arithmetic for numbers where numbers "wrap around" after reaching a certain value, called the modulus. It mainly uses remainders to get the value after wrap around. It is often referred to as "clock arithmetic. As you can see, the time values wrap after reaching 12
10 min read
Modular Exponentiation (Power in Modular Arithmetic)
Modular Exponentiation is the process of computing: xy (mod  p). where x, y, and p are integers. It efficiently calculates the remainder when xy is divided by p or (xy) % p, even for very large y. Examples : Input: x = 2, y = 3, p = 5Output: 3Explanation: 2^3 % 5 = 8 % 5 = 3.Input: x = 2, y = 5, p =
8 min read
Modular multiplicative inverse
Given two integers A and M, find the modular multiplicative inverse of A under modulo M.The modular multiplicative inverse is an integer X such that: A * X ≡ 1 (mod M) Note: The value of X should be in the range {1, 2, ... M-1}, i.e., in the range of integer modulo M. ( Note that X cannot be 0 as A*
15+ min read
Multiplicative order
In number theory, given an integer A and a positive integer N with gcd( A , N) = 1, the multiplicative order of a modulo N is the smallest positive integer k with A^k( mod N ) = 1. ( 0 < K < N ) Examples : Input : A = 4 , N = 7 Output : 3 explanation : GCD(4, 7) = 1 A^k( mod N ) = 1 ( smallest
7 min read
Modular Multiplication
Modular arithmetic, or clock arithmetic, is a system of arithmetic for integers, where numbers "wrap around" upon reaching a certain value This mathematical concept is widely used in various fields such as computer science, cryptography, number theory, and even everyday situations like clock time ca
6 min read
Modular Division
Modular division is the process of dividing one number by another in modular arithmetic. In modular arithmetic, division is defined differently from regular arithmetic because there is no direct "division" operation. Instead, modular division involves multiplying by the modular multiplicative invers
10 min read
Modulus on Negative Numbers
The modulus operator, denoted as %, returns the remainder when one number (the dividend) is divided by another number (the divisor). Modulus of Positive NumbersProblem: What is 7 mod 5?Solution: From Quotient Remainder Theorem, Dividend=Divisor*Quotient + Remainder7 = 5*1 + 2, which gives 2 as the r
7 min read
Problems on Modular Arithmetic
Euler's criterion (Check if square root under modulo p exists)
Given a number 'n' and a prime p, find if square root of n under modulo p exists or not. A number x is square root of n under modulo p if (x*x)%p = n%p. Examples : Input: n = 2, p = 5 Output: false There doesn't exist a number x such that (x*x)%5 is 2 Input: n = 2, p = 7 Output: true There exists a
11 min read
Find sum of modulo K of first N natural number
Given two integer N ans K, the task is to find sum of modulo K of first N natural numbers i.e 1%K + 2%K + ..... + N%K. Examples : Input : N = 10 and K = 2. Output : 5 Sum = 1%2 + 2%2 + 3%2 + 4%2 + 5%2 + 6%2 + 7%2 + 8%2 + 9%2 + 10%2 = 1 + 0 + 1 + 0 + 1 + 0 + 1 + 0 + 1 + 0 = 5.Recommended PracticeReve
9 min read
How to compute mod of a big number?
Given a big number 'num' represented as string and an integer x, find value of "num % a" or "num mod a". Output is expected as an integer. Examples : Input: num = "12316767678678", a = 10 Output: num (mod a) ? 8 The idea is to process all digits one by one and use the property that xy (mod a) ? ((x
4 min read
Exponential Squaring (Fast Modulo Multiplication)
Given two numbers base and exp, we need to compute baseexp under Modulo 10^9+7 Examples: Input : base = 2, exp = 2Output : 4Input : base = 5, exp = 100000Output : 754573817In competitions, for calculating large powers of a number we are given a modulus value(a large prime number) because as the valu
12 min read
Trick for modular division ( (x1 * x2 .... xn) / b ) mod (m)
Given integers x1, x2, x3......xn, b, and m, we are supposed to find the result of ((x1*x2....xn)/b)mod(m). Example 1: Suppose that we are required to find (55C5)%(1000000007) i.e ((55*54*53*52*51)/120)%1000000007 Naive Method : Simply calculate the product (55*54*53*52*51)= say x,Divide x by 120 an
9 min read
Modular Multiplication
Modular arithmetic, or clock arithmetic, is a system of arithmetic for integers, where numbers "wrap around" upon reaching a certain value This mathematical concept is widely used in various fields such as computer science, cryptography, number theory, and even everyday situations like clock time ca
6 min read
Difference between Modulo and Modulus
In the world of Programming and Mathematics we often encounter the two terms "Modulo" and "Modulus". In programming we use the operator "%" to perform modulo of two numbers. It basically finds the remainder when a number x is divided by another number N. It is denoted by : x mod N where x : Dividend
2 min read
Modulo Operations in Programming With Negative Results
In programming, the modulo operation gives the remainder or signed remainder of a division, after one integer is divided by another integer. It is one of the most used operators in programming. This article discusses when and why the modulo operation yields a negative result. Examples: In C, 3 % 2 r
15+ min read
Modulo 10^9+7 (1000000007)
In most programming competitions, we are required to answer the result in 10^9+7 modulo. The reason behind this is, if problem constraints are large integers, only efficient algorithms can solve them in an allowed limited time.What is modulo operation: The remainder obtained after the division opera
10 min read
Fibonacci modulo p
The Fibonacci sequence is defined as [Tex]F_i [/Tex]= [Tex]F_{i-1} [/Tex]+ [Tex]F_{i-2} [/Tex]where [Tex]F_1 [/Tex]= 1 and [Tex]F_2 [/Tex]= 1 are the seeds. For a given prime number p, consider a new sequence which is (Fibonacci sequence) mod p. For example for p = 5, the new sequence would be 1, 1,
5 min read
Modulo of a large Binary String
Given a large binary string str and an integer K, the task is to find the value of str % K.Examples: Input: str = "1101", K = 45 Output: 13 decimal(1101) % 45 = 13 % 45 = 13 Input: str = "11010101", K = 112 Output: 101 decimal(11010101) % 112 = 213 % 112 = 101 Approach: It is known that (str % K) wh
5 min read
Modular multiplicative inverse from 1 to n
Give a positive integer n, find modular multiplicative inverse of all integer from 1 to n with respect to a big prime number, say, 'prime'. The modular multiplicative inverse of a is an integer 'x' such that. a x ? 1 (mod prime) Examples: Input : n = 10, prime = 17 Output : 1 9 6 13 7 3 5 15 2 12 Ex
9 min read
Modular exponentiation (Recursive)
Given three numbers a, b and c, we need to find (ab) % cNow why do “% c†after exponentiation, because ab will be really large even for relatively small values of a, b and that is a problem because the data type of the language that we try to code the problem, will most probably not let us store suc
6 min read
Chinese Remainder Theorem
Introduction to Chinese Remainder Theorem
We are given two arrays num[0..k-1] and rem[0..k-1]. In num[0..k-1], every pair is coprime (gcd for every pair is 1). We need to find minimum positive number x such that: x % num[0] = rem[0], x % num[1] = rem[1], .......................x % num[k-1] = rem[k-1] Basically, we are given k numbers which
7 min read
Implementation of Chinese Remainder theorem (Inverse Modulo based implementation)
We are given two arrays num[0..k-1] and rem[0..k-1]. In num[0..k-1], every pair is coprime (gcd for every pair is 1). We need to find minimum positive number x such that: x % num[0] = rem[0], x % num[1] = rem[1], ....................... x % num[k-1] = rem[k-1] Example: Input: num[] = {3, 4, 5}, rem[
11 min read
Cyclic Redundancy Check and Modulo-2 Division
Cyclic Redundancy Check or CRC is a method of detecting accidental changes/errors in the communication channel. CRC uses Generator Polynomial which is available on both sender and receiver side. An example generator polynomial is of the form like x3 + x + 1. This generator polynomial represents key
15+ min read
Using Chinese Remainder Theorem to Combine Modular equations
Given N modular equations: A ? x1mod(m1) . . A ? xnmod(mn) Find x in the equation A ? xmod(m1*m2*m3..*mn) where mi is prime, or a power of a prime, and i takes values from 1 to n. The input is given as two arrays, the first being an array containing values of each xi, and the second array containing
12 min read