Part 0: Why Traditional Multiplication Is Inefficient

We all have fond memories of learning multiplication in school. I have a little secret to share: during rainy recesses, while others played games, I often challenged myself by multiplying large numbers for fun. The thrill of crunching numbers was exhilarating! I even participated in a multiplication contest called the 'Super 144,' where we raced to complete a 12x12 grid of numbers. With dedicated practice, I honed my skills down to a time of just over two minutes.

Despite my enthusiasm for multiplication, I never considered the possibility of improving the process.

For example, let’s multiply 103 by 222:

We compute 2 times 3 times 1 + 2 times 0 times 10 + 2 times 1 times 100 + 20 times 3 times 1 + 20 times 0 times 10 + 20 times 1 times 100 = 22800.

In general, multiplying two n-digit numbers requires O(n²) operations, where the big-O notation indicates that the quadratic term n² dominates the growth as n increases.

Now, let’s fulfill our childhood dreams of enhancing this algorithm!

Big-O Notation Explained

Take a look at the following graphs, which I created using desmos.com.

If you ask a mathematician whether (x²) and (x² + x^{1/3}) are equivalent, they might react dramatically due to the complexities involved, especially when considering topology. At least, that was my initial reaction, given my limited understanding of that field.

However, computers do not concern themselves with such complexities. When analyzing performance, if two functions grow at the same rate for large inputs, that is often sufficient for practical applications. The graphs reveal that while (x²) and (2x²) appear similar at large values, they differ only by a constant factor. On the other hand, an exponentially growing function like (10^x) far surpasses (10^{80}) (the estimated number of atoms in the universe) when (x) reaches 100.

Part I: Representing Numbers as Polynomials

Expressing integers as polynomials may seem unusual at first. For instance, representing 1342 as (x³ + 3x² + 4x + 2) (with (x = 10)) is less intuitive than writing it as (1000 + 300 + 40 + 2).

To multiply two large n-digit numbers in base (b), we treat each number as a polynomial. By splitting the n-digit number into (r) parts, we create an (n/r)-term polynomial. For instance, consider (b = 10), (r = 3), and the number 142,122,912.

This method works well when (r = 3), resulting in a polynomial representation. If (n) is not perfectly divisible by (r), we can prepend zeros to maintain consistency.

Why is this useful? By sampling a polynomial at (N + 1) points, we can determine its coefficients.

Now, let's explore how sampling polynomials allows us to deduce their coefficients.

Sampling Polynomials to Identify Coefficients (Optional)

This section examines the reasoning behind sampling polynomials to discover their coefficients. If two polynomials of degree (N) agree on (N + 1) points, they must be identical.

For example, consider a polynomial of order 2: (P(z) = az² + bz + c). According to the fundamental theorem of algebra, this can be factored as (A(z - r)(z - w)), indicating that (w) and (r) are roots.

If we assume (P(z)) has more than two roots, we can derive a contradiction, confirming that (P) can have at most two roots.

Now, if we have two polynomials, (P) and (Q), of order (N) that agree on (N + 1) points, the difference (P - Q) would be a polynomial of order (N) with (N + 1) roots, which is impossible. Thus, if (P) and (Q) agree on (N + 1) points, they are the same.

Part II: Divide and Conquer - A Worked Example

Let’s consider a large number, (p), with 24 digits:

(p = 292,103,243,859,143,157,364,152).

We express it as a polynomial:

(P(x) = 292,103 x³ + 243,859 x² + 143,157 x + 364,152) with (P(10^6) = p).

To compute the product (pq), where (q = 124,153,913,241,143,634,899,130), we can express (Q) similarly. Rather than multiplying directly, we find the polynomial representation of (t), (T), which will be of a higher order than (P) and (Q).

To compute (T)’s coefficients, we sample (T) at (2r - 1 = 7) points. This allows us to calculate values efficiently, reducing the computational load significantly.

Running Time Analysis

The cost of multiplying two n-digit numbers using Toom's algorithm follows a specific pattern. Each multiplication operation of two numbers of length approximately (n/r) incurs a cost of (T(n/r)).

Overall, we have derived the big-O of the runtime, which provides insight into the efficiency of this multiplication method.

Optimizing (r)

As (n) increases, we seek an optimal value for (r) that adjusts with (n). This optimization balances the cost of the reassembly matrix, which scales with (O(r²)).

In conclusion, our analysis leads to a more sophisticated understanding of how to adjust our algorithm for efficiency as the size of the numbers grows.

How Significant Is This Improvement?

It may seem reasonable that I overlooked this method as a child. However, the graph below illustrates our big-O function, comparing it to traditional (O(n²)) multiplication. The results show that while the new approach is eventually faster, it requires numbers with nearly 400 digits before notable improvements are seen.

For practical applications in fields like AI and physics, where large computations are common, this algorithm holds tremendous potential.

How profound is this result?

The beauty of this method lies in its simplicity. Despite being groundbreaking, the Toom-Cook algorithm illustrates how mathematical discoveries can often be hiding in plain sight.

This is why mathematicians rigorously question assumptions rather than accepting them at face value, as the vast landscape of mathematics continually surprises us.

Stay tuned for future explorations into even faster multiplication techniques, such as those utilizing fast Fourier transforms!

The first video, titled "How to multiply ANY numbers the fast way - Fast Math Trick," provides practical insights into efficient multiplication techniques.

The second video, "Multiplying - Large numbers," further elaborates on strategies for handling large numerical calculations effectively.