Modular Division

Given three positive integers a, b, and M, the objective is to find (a/b) % M i.e., find the value of (a × b^-1) % M, where b^-1is the modular inverse of b modulo M.

Examples:

Input: a = 10, b = 2, M = 13
Output: 5
Explanation: The modular inverse of 2 modulo 13 is 7, so (10 / 2) % 13 = (10 × 7) % 13 = 70 % 13 = 5.
Input: a = 7, b = 4, M = 9
Output: 4
Explanation: The modular inverse of 4 modulo 9 is 7, so (7 / 4) % 9 = (7 × 7) % 9 = 49 % 9 = 4.

Try It Yourself

Table of Content

Modular division is the process of dividing one number by another within the rules of modular arithmetic. Unlike regular arithmetic, modular systems do not support direct division. Instead, division is performed by multiplying the dividend by the modular multiplicative inverse of the divisor under a given modulus.

In simple terms, to compute (a/b) % M we instead calculate (a × b^-1) % M where b^-1is the modular inverse of b modulo M ( i.e., b × b^-1≡ 1 mod M ).

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 of a number 'a' exists under modulo 'm' if 'a' and 'm' are co-prime, i.e., GCD of them is 1.

Modular Arithmetic Rules:

(a * b) % m = ((a % m) * (b % m)) % m
(a + b) % m = ((a % m) + (b % m)) % m
(a - b) % m = ((a % m) - (b % m) + m) % m // m is added to handle negative numbers
But,
(a / b) % m not 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.

[Approach 1] Using Fermat's Little Theorem (when `M` is prime) O(log M) Time and O(1) Space

If the modulus m is a prime number, we can use Fermat’s Little Theorem to find the modular inverse of b. According to the theorem, the inverse of b modulo m is b ^M-2 % M. So we can use Modular Exponentiation for computing b ^M-2 % M.

C++

#include <iostream>
#include <algorithm>
using namespace std;

// Binary exponentiation
int power(int base, int exp, int mod) {
    int result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp % 2 == 1)
            result = (1LL * result * base) % mod;
        base = (1LL * base * base) % mod;
        exp /= 2;
    }
    return result;
}

// Modular inverse using Fermat's Little Theorem
int modInverse(int b, int m) {
    return power(b, m - 2, m);
}

int modDivide(int a, int b, int m) {
    
    // Division not possible
    if (b == 0 || __gcd(b, m) != 1)
        return -1;
    int inv = modInverse(b, m);
    return (1LL * a * inv) % m;
}

int main() {
    int a = 10, b = 2, m = 13;
    cout << modDivide(a, b, m) << "\n";
    return 0;
}

#include <stdio.h>

// Binary exponentiation
int power(int base, int exp, int mod) {
    int result = 1;
    base %= mod;
    while (exp > 0) {
        if (exp % 2 == 1)
            result = (1LL * result * base) % mod;
        base = (1LL * base * base) % mod;
        exp /= 2;
    }
    return result;
}

// GCD
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

// Modular inverse
int modInverse(int b, int m) {
    return power(b, m - 2, m);
}

int modDivide(int a, int b, int m) {
     // Division not possible
    if (b == 0 || gcd(b, m) != 1)
        return -1;
    int inv = modInverse(b, m);
    return (1LL * a * inv) % m;
}

int main() {
    int a = 10, b = 2, m = 13;
    printf("%d\n", modDivide(a, b, m));
    return 0;
}

Java

class GfG {
    
    // Binary exponentiation
    static int power(int base, int exp, int mod) {
        int result = 1;
        base %= mod;
        while (exp > 0) {
            if ((exp & 1) == 1)
                result = (int)((1L * result * base) % mod);
            base = (int)((1L * base * base) % mod);
            exp >>= 1;
        }
        return result;
    }
    
    // Function to compute GCD of two numbers
    static int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    static int modInverse(int b, int m) {
        return power(b, m - 2, m);
    }
    
    static int modDivide(int a, int b, int m) {
        
         // Division not possible
        if (b == 0 || gcd(b, m) != 1)
            return -1;
        int inv = modInverse(b, m);
        return (int)((1L * a * inv) % m);
    }
    
    public static void main(String[] args) {
        int a = 10, b = 2, m = 13;
        System.out.println(modDivide(a, b, m));
    }
}

Python

# Binary exponentiation
def power(base, exp, mod):
    result = 1
    base %= mod
    while exp > 0:
        if exp % 2 == 1:
            result = (result * base) % mod
        base = (base * base) % mod
        exp //= 2
    return result

# function to calculate GCD
def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def modInverse(b, m):
    return power(b, m - 2, m)

def modDivide(a, b, m):
    
     # Division not possible
    if b == 0 or gcd(b, m) != 1:
        return -1
    inv = modInverse(b, m)
    return (a * inv) % m

if __name__ == "__main__":
    a, b, m = 10, 2, 13
print(modDivide(a, b, m))

using System;

class GfG {
    // Binary exponentiation
    static int Power(int baseVal, int exp, int mod) {
        int result = 1;
        baseVal %= mod;
        while (exp > 0) {
            if ((exp & 1) == 1)
                result = (int)((1L * result * baseVal) % mod);
            baseVal = (int)((1L * baseVal * baseVal) % mod);
            exp >>= 1;
        }
        return result;
    }   
    
    // Function to compute GCD of two numbers
    static int GCD(int a, int b) {
        return b == 0 ? a : GCD(b, a % b);
    }

    static int ModInverse(int b, int m) {
        return Power(b, m - 2, m);
    }

    static int ModDivide(int a, int b, int m) {
         // Division not possible
        if (b == 0 || GCD(b, m) != 1)
            return -1;
        int inv = ModInverse(b, m);
        return (int)((1L * a * inv) % m);
    }
    
    static void Main() {
        int a = 10, b = 2, m = 13;
        Console.WriteLine(ModDivide(a, b, m));
    }
}

JavaScript

// Function to compute (base^exp) % mod using binary exponentiation
function power(base, exp, mod) {
    let result = 1;
    base %= mod;

    while (exp > 0) {
        if (exp % 2 === 1) {
            result = (result * base) % mod;
        }
        base = (base * base) % mod;
        exp = Math.floor(exp / 2);
    }

    return result;
}

// Function to compute GCD of two numbers
function gcd(a, b) {
    return b === 0 ? a : gcd(b, a % b);
}

// Function to compute modular inverse using Fermat's Little Theorem
function modInverse(b, m) {
    return power(b, m - 2, m); // Only valid if m is prime
}

// Function to perform modular division (a / b) % m
function modDivide(a, b, m) {
    
    // Division not defined
    if (b === 0 || gcd(b, m) !== 1) {
        return -1; 
    }

    let inv = modInverse(b, m);
    return (a * inv) % m;
}

// Driver Code
let a = 10, b = 2, m = 13;
console.log(modDivide(a, b, m));

Output

[Approach 2] Extended Euclidean Algorithm O(log M) Time and O(1) Space

To find the modular inverse of a number b modulo M using the Extended Euclidean Algorithm, we aim to solve the equation b * x + M * y = gcd(b, M). If the greatest common divisor gcd(b, M) is 1, then x is the modular inverse of b modulo M. The Extended Euclidean Algorithm computes both gcd and the coefficients x and y that satisfy this linear combination. Once x is found, we take its positive equivalent by calculating (x % M + M) % M to get the correct modular inverse. This approach works for any modulus M, not necessarily prime.

C++

#include <iostream>
using namespace std;

// Extended Euclidean Algorithm to find gcd and coefficients x, y
int gcdExtended(int a, int b, int &x, int &y) {
    if (a == 0) {
        x = 0;
        y = 1;
        return b;
    }

    int x1, y1;
    int gcd = gcdExtended(b % a, a, x1, y1);

    x = y1 - (b / a) * x1;
    y = x1;

    return gcd;
}

// Compute modular inverse of b modulo M
int modInverse(int b, int M) {
    int x, y;
    int g = gcdExtended(b, M, x, y);
    if (g != 1)
        return -1;
        
    // Ensure positive result    
    return (x % M + M) % M;
}

// Perform (a / b) % M
int modDivide(int a, int b, int M) {
    a %= M;
    int inv = modInverse(b, M);
    if (inv == -1)
        return -1;
    return (1LL * a * inv) % M;
}

int main() {
    int a = 10, b = 2, M = 13;
    int result = modDivide(a, b, M);
    cout << result << "\n";
    return 0;
}

#include <stdio.h>

// Extended Euclidean Algorithm to find 
// gcd and coefficients x, y
int gcdExtended(int a, int b, int *x, int *y) {
    if (a == 0) {
        *x = 0;
        *y = 1;
        return b;
    }

    int x1, y1;
    int gcd = gcdExtended(b % a, a, &x1, &y1);

    *x = y1 - (b / a) * x1;
    *y = x1;

    return gcd;
}

// Function to compute modular inverse of b modulo M
int modInverse(int b, int M) {
    int x, y;
    int g = gcdExtended(b, M, &x, &y);
    if (g != 1)
        return -1;
    // Ensure positive result
    return (x % M + M) % M;  
}

// Function to compute (a / b) % M
int modDivide(int a, int b, int M) {
    a = a % M;
    int inv = modInverse(b, M);
    if (inv == -1)
        return -1;
    return (inv * a) % M;
}

int main() {
    int a = 10, b = 2, M = 13;
    int result = modDivide(a, b, M);
    printf("%d\n", result);
    return 0;
}