7.5.3.1. Naive Approach for Modular Exponentiation

How can we compute a^b modulo N? You might be wondering that why cannot I do the following multiply a with itself and then take mod and then again multiply with a and then take mod and so on. This operation DOT and then in subscript N means I am doing multiplication modulo N. So basically I am saying that you multiply a to itself b - 1 number of times and then keep on taking mod.

To compute a raised to the power of b modulo N using the naive approach, one would repeatedly multiply a by itself b - 1 times, and after each multiplication, take the modulo N of the result. This process results in b-1 modular multiplications, which means if b is a large number, the algorithm becomes computationally expensive. For example, to compute a^5 modulo N, you'd multiply a by itself four more times, taking the modulo after each multiplication.

Think of this like baking a large cake. If the recipe calls for 5 cups of sugar, you need to combine 4 more cups with that first cup each time. If you use a bigger cup instead, just remember to adjust the total amount at the end (the modulo). If you’re making a cake that needs a certain number of cups, repeatedly measuring out each cup before finally adding it together is slow, especially for large amounts.

So, if you perform b times polynomial in n number of operations, but your b itself could be as large as 2 to the power 1024 bit number; those many, this is an enormously large quantity.

The naive method for modular exponentiation, while it seems straightforward, has an exponential time complexity. This is because as b (exponent) can be very large—up to 2^n for n-bit numbers—the amount of computation required quickly becomes infeasible. Therefore, although the naive approach appears like polynomial time in n, the sheer size of b makes the total computational workload grow exponentially.

Imagine calculating the total height of a stack of coins where each coin represents a number in similar fashion to the number of operations. If you wisely plan and only maintain a few coins at a time, you can estimate much faster than stacking all the coins each time, which reflects cumbersome amounts of work as the number of coins (the exponent) increases.

So, now we will see a very nice method, which is a polynomial time algorithm for performing modular exponentiation and this is called as the square and multiply approach.

Given the inefficiency of the naive method, a better approach emerges known as square-and-multiply. This method allows us to compute powers of a modulo N much more efficiently by squaring previously calculated results and selectively multiplying them based on the binary representation of the exponent. Instead of computing a power of 2, we break it down to accumulate results faster.

Think of this like finding shortcuts while walking through a forest where you can take several paths to reach the same destination. Instead of following a long and tedious path (the naive method), you can take clever shortcuts that allow you to reach your destination much quicker (the square-and-multiply approach).

--