7.5.2. Complexity Measurement

Now, what will be the complexity measurement? How exactly we judge whether our given algorithm that we designed for performing this modular arithmetic operations are efficient or not. Our complexity measurement will be how many operations are we performing as a function of the number of bits that we need to represent as integer values a, b and N. And we will be requiring algorithms where the number of operations that we perform is a polynomial function in n.

Complexity measurement helps determine how efficient an algorithm is based on how many operations it needs to perform. Here, we focus on integer values a, b, and modulus N. We express these values in bits. The size of the numbers is represented as 'n', which is the number of bits needed to represent these integers. An efficient algorithm should operate in polynomial time, meaning that the number of operations should grow polynomially with the increase of 'n'.

Think of a recipe that requires different steps to prepare a dish. If a recipe has a moderate number of steps (e.g., 10 steps for 10 servings), it's manageable (polynomial time). But if the recipe has to double every time you add just one ingredient (exponential time), it becomes much harder to complete without an efficient method.

Because, typically, we prefer algorithms whose running time is polynomial function of your parameter; the parameter here is the size of your integer a, size of your integer b and the size of your modulus N, which is the number of bits that you need to represent those values which is n. We do not prefer any algorithm which is exponential time or sub-exponential time in the number of bits.

In algorithm design, we generally seek solutions that run efficiently, meaning they don't take an unreasonable amount of time. Specifically, we want the number of operations to be a polynomial function of the input size. If an algorithm grows exponentially with input size, it can quickly become impractical, as the time to complete the task increases dramatically.

Imagine trying to find a book in a massive library. A well-organized library (polynomial time) lets you find a book quickly by looking up the catalog. However, if you had to physically check every book one by one without a system (exponential time), you could spend days searching.

So, it turns out that addition, subtraction and modular multiplication all of them can be performed in polynomial in n number of bit operations.

Basic operations like addition, subtraction, and multiplication can be performed efficiently. The operations do not require an excessive amount of time relative to the size of the input bits. This means algorithms for these operations are designed efficiently.

Think of simple calculations like adding two numbers. If you can use a calculator, you can do it quickly, even if the numbers are large, thanks to effective algorithms implemented in the device.

Now, what about modular exponentiation? How can we compute ab 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.

Modular exponentiation is a specific operation that involves raising a number to a power, then taking a modulus. Although it seems simple to repeatedly multiply the base with itself, when the exponent is large, this method is not efficient and can take an enormous amount of time. We need a smarter technique to handle this efficiently.

Imagine you need to raise a tall building height to a certain power (like doubling it). If you tried stacking the building bricks one by one, it could take forever. However, using a construction crane to lift entire sections of the building can make this process much faster.

So, this operation DOT and then in subscript N, means I am doing multiplication modulo N... this will require me to perform b times polynomial in n number of operations.

If we apply the naive method of multiplying a number 'a' by itself 'b' times while taking modulus, we will have to do a lot of operations. When 'b' is also large, this results in a very inefficient approach because you would be doing operations multiple times based on the size of 'b'.

Consider watering a large garden. If you use a tiny watering can, you have to refill it many times. But if you have a hose, you can water much more area quickly. The hose represents more efficient methods.

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.

The square and multiply technique optimizes the process of modular exponentiation. Instead of multiplying a repeatedly, it uses the binary decomposition of the exponent to reduce the number of multiplication operations required. By squaring and then selectively multiplying based on the bits of the exponent, the number of operations is drastically reduced.

Think of needing to drive across a city to meet friends. Instead of going directly to friends’ house every time, you can take shortcuts by recognizing intersections along the way—this saves time just like the square and multiply method saves operations.

--