Modular Exponentiation

Modular exponentiation (also called powmod or modpow in programming) is the calculation of an integer power followed by a reduction modulo a positive integer $ n $.

Mathematically, it involves calculating $ a^b \mod n $, where $ a $ is the base, $ b $ is the exponent, and $ n $ is the modulo (a strictly positive integer).

Modular exponentiation is a fundamental tool in modern cryptography, particularly in public-key systems.

The calculation amounts to finding the remainder of the Euclidean division of $ a^b $ by $ n $.

A direct method is to calculate the full power and then take the remainder modulo $ n $.

However, this method quickly becomes impractical because the values of $ a^b $ grow exponentially with $ b $.

In practice, it is preferable to reduce modulo $ n $ at each step of the calculation using the property $ x \equiv y \mod n $, alors $ x \cdot z \equiv y \cdot z \mod n $

This property makes it possible to perform intermediate reductions and avoid the manipulation of gigantic numbers.

Calculating the last $ x $ digits of a number in decimal writing is equivalent to performing a modulo $ 10^x $ calculation.

This property is based on the fact that working modulo $ 10^x $ preserves exactly the last $ x $ digits in base 10.

The most commonly used algorithm is modular fast exponentiation, also called the square-and-multiply method. It is based on the binary representation of the exponent $ e $.

Writing $ e=\sum_{i=0}^{m-1}a_{i}2^{i} $ over $ m $ bits with $ a_i $ the binary values (0 or 1) in writing in base 2 of $ e $ (with $ a_{m-1} = 1 $)

Then $ b^e $ can be written $$ b^e = b^{\left( \sum_{i=0}^{n-1} a_i \cdot 2^i \right)} = \prod_{i=0}^{n-1} \left( b^{2^i} \right)^{a_i} $$

And so $$ b^e \mod n \equiv \prod_{i=0}^{n-1} \left( b^{2^i} \right)^{a_i} \mod n $$

Here is the implementation of fast modular exponentiation in pseudocode:// pseudocode
function powmod(base b, exponent e, modulus m) {
r = 1
b = b % m
if (b == 0) return 0
while (e > 0) {
if (e % 2) r = (r * b) % m
e = e >> 1
b = (b ** 2) % m
}
return r
}

In theory, the fast exponentiation algorithm is the one that requires the fewest steps. The number of steps depends on the bit size of the exponent $ b $.

For a manual calculation, an efficient method is to:

— Decompose the exponent into powers of 2

— Successively calculate the squares modulo $ n $

— Multiply the useful powers (bits equal to $ 1 $)

In practice, for small values of $ a $, $ b $, and $ n $, calculating the power first and then the modulo (using Euclidean division) is more instinctive.

This calculation is known as the discrete logarithm problem. Some solutions can be found by brute force but there is no trivial general solution.

Calculus uses exponent and modulus that are generally defined over the natural number domain set N.

It is possible to use rational numbers but it is not handled here.