# Lecture 11: Integer Arithmetic, Karatsuba Multiplication

Flash and JavaScript are required for this feature.

Description: This is the first of two lectures on numerics, covering irrational numbers, high-precision computation, and Karatsuba multiplication.

The following content is provided under a Creative Commons license. Your support will help MIT OpenCourseWare continue to offer high quality educational resources for free. To make a donation or view additional materials from hundreds of MIT courses, visit MIT OpenCourseWare at ocw.mit.edu.

PROFESSOR: I hope you're all recovered from the quiz. Our apologies for hard questions, but it's just the first quiz. We have a lot more fun things to do in 006. So today's lecture today's lecture is a light lecture, I would even call it a recreational mathematics lecture. And so, thanks for coming. I'll make it worth your while, all right?

So we're going to talk about irrationals. The motivation behind this is really that every once in awhile we are going to have a situation where we want to compute with numbers that are much longer than 64 bits, which is really the word length in standard computer these days. It used to be 8 bits back in the day. For most of my adult life it was 32 bits. And recently Intel and AMD have gone to 64-bit processors. But 64 bits ain't near enough if you want to do what's called high precision computation, you want to find precisely the weight of a neutrino, if you're a physicist, for example. And that, you're talking about literally a hundred decimal digits, which is obviously much more than 64 bits. And that's just one example.

So what happens if you want to compute the square root of 2 to a million digits, or pi to 10 million digits? How do you do that on a computer? So that's what we're going to do for this module, which is a short module on numerics.

We'll have a lecture today and another one on Tuesday telling you about techniques that use, among other things, Newton's method to compute irrational numbers, as one example, to arbitrary precision And for your problem set you are you going to look at different application that corresponds to encryption, RSA encryption, where you have to work with primes. These are now integers, but you work with primes that are thousands of bits long, so again, much more than 64 bits. And so you have to think about how you're going to multiply numbers that are thousands of bits long, how you're going to divide numbers that are thousands of bits long, and that's really the purpose of this module.

So let's start off by talking about irrationals. And Pythagoras, whom I'm sure you've all heard of is credited with the discovery that a square's diagonal and its side are incommensurable. So you can't really express the ratio as a rational number, as a ratio of integers. Now it turns out that the Babylonians and the Indians knew this way before Pythagoras, but he gets credit for the Pythagoras theorem.

And there's also a Greek philosopher, in fact, maybe he was first a philosopher and then a mathematician, and he the espoused a philosophy that, I guess, is called Pythagorean mysticism, that said that all is number, so the world is about numbers. And he worshipped numbers, his followers worshipped numbers. And the problem here was that he didn't really like the square root of 2 because he couldn't express it as a number, of what he thought of as a number, which was 1, 2, 3, et cetera, integers, whole numbers.

So he called this ratio speechless, something that he really couldn't explain. And irrationals were actually considered a threat to the mystics because they couldn't really explain what square root of 2 was. They'd try and measure it, and they would come up with the right answer because the next time around it would be a little bit different If they did things a little more precisely, or not so precisely. And it bothered them no end.

And so they tried to find patterns in irrationals because they considered them a threat. And they obviously didn't find patterns, but imagine if we could actually find patterns. I mean, that would be a really big deal, it would be better than p equals np, if you know what I mean. If you don't it doesn't matter.

So that's another of motivation for high precision arithmetic. Let's try and find patterns in irrationals if you go to millions and trillions of digits, maybe it's just a matter of time before we discover that there's no such thing as irrational numbers. Who knows? So let's do that for the rest of this lecture. Let's try and figure out how we're going to compute irrational numbers, or things like square root of 2, to arbitrary precision. So we can go play around, and we'll give you some code, and you can play with it.

So if you look at square root of 2-- I'll just put this up here-- so it's 1.414, you probably all know that. Then it's 213,562,373,095,048 et cetera. I mean, I don't see a pattern there. I see a zero, a couple of zeroes here. It's hard to imagine-- you'd probably want to think of a computer program that generates square root of 2, and then maybe a different computer program that's looking for patterns.

So let's not worry about the square root of 2. I want to digress a little bit. I did say this was a bit of a recreational mathematics lecture. And let's talk about something completely different, which are Catalan numbers. So these are really my favorite numbers in the world. And people like primes, some people like irrationals, I like Catalan numbers.

Catalan numbers are-- they show up all over the place. How many of you know what Catalan numbers are? Oh good. Excellent. So Catalan numbers have a recursive definition. You can think of them as representing the cardinality of the set p of balanced parentheses strings.

And we're going to recursively define these strings as follows. We're going to have lambda belonging to p where lambda is the empty string. And that's rule one. Rule two is if alpha and beta belong to p then I'm going to put a paren, open paren, alpha, close paren, and then beta. And that belongs to p.

So you iteratively or recursively apply this rule over and over, and you start getting strings that are balanced. So this is balanced. Now that's not balanced, this is not balanced, and so on and so forth. Obviously things get more complicated in terms of the parentheses if when you have more brackets or parentheses.

And so, the nice thing about this definition is that you can get every non-empty balanced paren string, via rule two, from a unique alpha, beta pair. So as an example, suppose you want to generate the string that looks like this-- So that's a little more complicated than the strings that we have looked at so far-- then you obtain that by having alpha be this simple string. And then you put the brackets around that, and then your beta corresponds to this.

So now alpha and beta were previously generated, so if you applied rule two to the empty string, with alpha being the empty string and beta being the empty string, then you get this thing here. And obviously you could get beta by setting alpha to be the empty string and beta to be this string that you just generated, and so on and so forth. So you just keep going and the strings get longer and longer. The cardinality of the set gets bigger and bigger. And those of the Catalan numbers. OK

And so, this is a non-trivial question, which is I'd like to enumerate the Catalan numbers, and compute, and get an analytical form for the cardinality of the set. And that's really what the Catalan number is. It's a cardinality of the set.

And so cn is the number of balanced parentheses strings with exactly n pairs of parentheses. And I have c0 equals 1, which is my base case. And that's just setting-- it's an empty string. I'm going to say that empty string is a string, and that's just setting up the base case.

And now I want an equation for cn plus 1. And I need to use the fact that I can get cn plus 1, a particular strain that belongs to this set, where I have n plus 1 parenthesis in a unique way from a string I've previously generated that was part of either the set that had n parentheses-- or it was combined using strings, where alpha was in some set that was maybe generated awhile back with a small n, or something significantly smaller than n, and another thing that was generated, beta, that was generated later, or maybe at the same time, et cetera.

So can someone tell me what an equation would be for cn plus 1 based on the cis that are less than n? So what about c1? Maybe I'll ask-- what about c1? What's c1? 1. c1 is 1 because all I have is this string, that's the only balanced string.

Now I have c0 and c1. What's an equation for c2 in terms of numbers. I want a number for c2 based on c0 and c1. Someone? Yeah.

AUDIENCE: C0 plus c1.

PROFESSOR: c0 plus c1? No, not quite right. How many strings do I have? c0 plus c1. Yeah, actually you're right. Well, the number is right but the equation is wrong. It's not quite that. You get a-- Yup.

AUDIENCE: So when something like c-- c1 times c1 plus c1.

PROFESSOR: c1 times c1 plus c1?

AUDIENCE: Yeah.

PROFESSOR: I think you want to use a c0.

AUDIENCE: OK. c0.

PROFESSOR: c0 Well, that's not quite right either. Someone else. Yeah. OK. You.

AUDIENCE: c0 times c1 plus c1 [INAUDIBLE].

PROFESSOR: c0 times c1-- c2 would be c0 times c1 plus c1 times c0. OK. And if you're setting the alpha-- So here's the thing, you set the alpha, and you choose the alpha, and then you choose the beta. And there's a couple of different ways that you could choose the alpha.

You could choose the alpha from-- you could make it a string that's empty, or you could make it the one string that you've generated so far, which is the standard simple string, the non-empty, the non-trivial balanced string. And you could do that in a couple different ways with alpha. And that's why you have two terms over there.

So the number, in terms of all of the equations I got, they all came out to be the same. It's 2, and that's correct. But this is the equation for it. And so now, tell me what a general equation is for cn plus 1 based on what we've learned so far for the c2 equation? Yeah, back to you.

AUDIENCE: So c0 times cn plus c1 times cn minus 1 all the way to cn times [INAUDIBLE].

PROFESSOR: Perfect. Good. That deserves a cushion. That wasn't me, it was you. And put it right there, breadbasket.

So cn plus 1 equals sigma, so you give me a summation, k equals 0 through n, ck, cn minus k where n is greater than or equal to 0. And you can figure this out, it's not particularly important as to exactly why this is true. You can think about it offline.

But the interesting thing is that this is a generator of, obviously, and it's going to give you a nice looking set of numbers. And I came in early and wrote that the Catalan in numbers up on the board going from c0, c1, c2, et cetera, just in case-- just in case you ever see these numbers in real life, or when you're writing computer programs. Or you're driving on the road, the next time you see a license plate 4862, turn around and tell your mom or dad, hey, that's the Catalan number. And maybe she'll be impressed.

This, of course, you're not going to see on a license plate, but you can always make up a bumper sticker or something, and you can have the c17 as being a bumper sticker on your car. I mean, that's the kind of thing that I'd do. Anyway, so it's just in case you see these numbers-- we might come back to this a little bit later in the class, but--

AUDIENCE: 42 is on that list.

PROFESSOR: 42 is on that list. Yeah, it has to be. 42 is on every list. 42 is the answer to every question. I am glad you guys didn't put 42 down in the answer to every quiz question. It doesn't quite work all the time, all right, but most of the time 42 is a good answer. Most of the time. OK good.

So let's get down to business. So we talked about Catalan numbers as a digression. If you see them you'll recognize them, I think. Let's talk about how we could compute. Let's go back to irrationals and talk about how we could compute square root of 2 and other things to arbitrary precision.

So what I want to do is to talk about Newton's method. And Newton's method is something you probably learned about in middle school, high school. And let's say you have a function y equals f of x where this is x and that's y, the coordinate axes. And we want to try and find the root of fx equals 0 through successive approximation.

For example, we might have f of x equals x squared minus a. And if a is 2 then you're trying to use Newton's method to find the root, and you're going to end up trying to compute square root of 2 or plus minus square root of 2, in this case. But you can go for a particular root, and you're try and converge to that.

So the way Newton's method works is it tries, geometrically speaking, it tries to find tangents-- and a different color chalk would be useful here but I don't seem to see one-- So what would happen is, let's say you are sitting out here, and it's successive approximation method, so this would give you x of i. And now you want to compute x of i plus 1. And what you're going to do is draw a tangent, like so, and find the intercept onto the x-axis, the x-intercept. And that is going to be your xi plus 1.

And you have to write an equation for that tangent. And this is, I guess, trying to figure out how much of middle school math or high school math that you remember. What is the equation for that tangent? Anybody? The equation for that tangent? What do you do in order to compute that tangent? Give me a name.

AUDIENCE: Derivative?

PROFESSOR: Derivative. Thank you. So what's the equation for that tangent? y equals-- Someone?

AUDIENCE: [INAUDIBLE]

PROFESSOR: It's a good think your middle school, high school teachers aren't here. Not you. You already got a cushion. Someone else. Someone else. All right. I'll start giving you some hints here. f of xi plus-- plus--

ALL: f prime.

PROFESSOR: f prime xi. Thank you. Thank you. All right. You get a cushion. I'm getting them. Whatever it takes. Here you go. Yeah. That was left-handed, by the way. I'm actually right-handed, as you know.

So what do we have here? So we have f prime xi. Now come on, let's finish it, finish it.

AUDIENCE: Times i minus xi.

PROFESSOR: Times xi is xi. Thank you. OK. So now I get it. You thought this was too simple a question. You guys were insulted by the question. So that's why you didn't tell me what it was At least, that's what I'm going to pretend to make myself feel better.

So y equals f of xi plus f prime xi, which is the derivative of f evaluated at xi times x minus xi, that's the equation for the line. And that's essentially what we have to do to compute things like square root of 2, which is iteratively applied Newton's method. The only problem is this is all good in theory that we can do-- take that equation turn it into xi plus 1 equals xi minus f of xi divided by f prime of xi. And if you end up doing f of x equals x squared minus a, then you have xi plus 1 equals xi minus xi squared minus a divided by 2xi, which is the derivative of x squared minus a evaluated at xi. And finally you get this equation, xi plus a divided by xi divided by 2.

So it's fairly straightforward. xi plus 1 equals xi plus a divided by xi divided by 2. And if you look at this, remember that a is typically a small number. I mean, it's two, in this case, if you're computing square root of 2. it may even be an integer, maybe a fraction. But you have to do a division here. And remember that since we want to compute things to millions of digits, potentially, these numbers, the xi numbers, are going to have millions of digits.

And so if you end up running this Newton method on a equals 2, then if I simulate what happens without worrying about the implementation, and this is what you'll get. You have x0-- you start with x0 equals 1 with a bunch of zeros. xi equals 1.5 with a bunch of zeros, et cetera. And then, x2 equals 1.41666 et cetera. That goes on. And we're not talking about fractions here, we're talking about floating point numbers that are integers with a certain amount of precision.

So you've decided that you want to compute this to d digits of precision where d may be a million. And so, really, here you would have a representation that's a million digits long that where, basically, everything is zero, and here everything but one is 0, or maybe a couple if you count the 1 here. And here you have all these sixes here, and so on and so forth. And you keep going, and you get x2 equals 1.414215686. And I want to write one more because I want to point out something that's important. 1.414213562.

And what's nice about this, if you go compare it with what you have up there, is that you have quadratic convergence using the Newton's method. And what do I mean by that? Well, quadratic convergence is a nice property. It's much better than linear convergence. Linear convergence would mean that you get an extra digit of precision for every iteration.

So in this case, actually, a quadratic is better. Usually we think of quadratic algorithms, and we are going to throw up. But linear algorithms is what we like. But in this case it's actually a good thing. You have this extended this quadratic rate of convergence where the number of digits that are correct doubles with every iteration, as you can see.

So here you have-- you start with, roughly, if you rounded this up you would get 5. So you're saying that that's one digit of precision in terms of the decimal. And then, now you're talking about 41421356, so that's 1, 2, 3, 4, 5, 6, 7, 8, so that's eight digits of precision here, four here, and so on and so forth.

So that's nice. That's why the Newton's method is actually used in practice because the number of digits doubles. This is a precision. So now you don't get too scared about calculating things that are a million because you kind of go and say, whoa, I mean, that's not so bad, that's only a logarithmic number of integrations. And it's not like you have to run for a million iterations. You go 2, 4, 8, 16, and now that exponential helps you, the geometric series helps you.

So that's the nice thing about the Newton's method. Haven't quite told you how we are going to compute the most important thing here with respect to a divided by xi. So this is just additions. You can imagine that if you have long numbers you'd end up doing addition fairly straightforwardly because you only have to worry about one carry, and so you go off.

And I'm sure you've added up numbers that are in tens, if not hundreds, of digits long but I'm guessing you haven't manually multiplied numbers that are hundreds of digits long. And if you have I'd be impressed, though I won't believe your result. But that's something that is kind of a painful thing to do. And so that's why we need computers. And that's multiplication and-- has anybody divided a hundred-digit number by another 50-digit number? No. So you need computers.

So we've got to be able to do that division there, a divided by xi, using computers. And so that's really the purpose of this and the next lecture If you're only going to do a high precision multiplication here. And try see what an algorithm would be for high precision multiplication because what we're going to do is, essentially, take the reciprocal of one over xi and then multiply that by a. And we need-- division is going to require multiplication. You don't really see a multiplication there other than a times 1 over xi.

And you can say, well, do we really need multiplication? Well, the answer is the division algorithm that is used in practice in most division algorithms have multiplication as a subroutine. So we're going to have to figure out high precision multiplication first-- It's a little bit easier than division-- and use it as a subroutine for high precision division, which we'll do next time.

So now we're sort of back in 006 land, if you will. We have a problem that is high precision multiplication, and we want to find an algorithm for it. And there's the vanilla algorithm that is going to take certain amounts of time, asymptotically speaking, and then there is better and better algorithms. As you can imagine, multiplication is just such a fundamental operation that people have looked at trying to reduce the complexity of high precision multiplication. So if you have n bits-- So what is the standard algorithm for multiplication take if you have n bits of precision?

AUDIENCE: N squared.

PROFESSOR: n squared. But you can do better. And the people are work on it. You can do fast Fourier transforms. We won't quite do that here. If you take 6.046 you'll probably learn about that. But we'll do a couple of algorithms that are better than the order n squared method, and we'll do one of those today.

So the way they're going to work with integers-- one little point that I need to make before we move ahead here is, generally, we going to say, for the purposes of 006, that we know the digits of precision up front because we want d digits of precision, maybe it's 42, maybe it's 125. In the case of our problem set in RSA we going to have it 1,024-bit numbers, maybe 2,048.

So we know d beforehand. And so what we want is an integer, which is 10 raised to d times the square root of 2, a floor, and which is essentially the same as that, 2 times 10 raised to 2 d. So we're going to treat these as integers, so we don't want to worry about decimal points and things like that. All of these things are going to be integers.

And there's no problem here. We can still use Newton's method. It just works on integers. And let's take a look at how we would apply Newton's method in standard form.

And we won't to really get to the part where we're going to go from division to multiplication today, as I said, we're just going to look at how you can multiply two numbers. So I didn't mean to say that we're going to look at Newton's method. We're going to look at high precision multiplication, and then, eventually, we're going to use that to build Newton's method which requires the division.

So I have two n-digit numbers, and the radix could be-- the base could be 2, 10. Normally, it doesn't really matter. 0 less than x, less than y, strictly less than r raised to n. That's standard for the ranges.

And what I have here is-- the way I'm going to do this is use our favorite strategy, which is divide and conquer, because I have n, which is large, need to break things down, break it into n by two-digit multiplications. And when, finally, I break things down, I get down to 64 bits, I just run one instruction on my computer to multiply the 64-bit numbers. And the standard machines, you would get 128 bits of result back when you multiply 64-bit numbers. So in some sense you only go down-- you don't go down to 1 bit, you go down to 64 and your machine does the rest.

So what we have here is you set x to be x1 where x1 is the high half, r raised to n over 2 plus x0. So x1 is the more significant half and x0 is the low half. And the same thing for y. y1, whoops, r raised to n over 2 plus y0. Now the ranges change. x0 and x1 are smaller, so that's what you have for x0 and x1. Same thing for y0 and y1.

So that's a fairly straightforward decomposition of this multiplication operation. And again, if you do things in a straightforward way you will create a recursive multiply, as I'll write here.

And what you do is you say let z0 equal x0 times y0, z two equals x2 times y2, and-- I missed z1, but z1 equals x0, y1 plus x1 y0. And I have, overall, z equals y equals x1 y1 times r raised to n plus x0 y1 plus x1 y0 times r raised to n over 2 plus x0 y0 zero. And this part here was z0, this part here was z1, and this part here was z2.

And if you look at, it you need four multiplies, 1, 2, 3, 4. And you need four multiplies of n by two-- n by two-digit numbers. And by now, after you have prepared for quiz two, I will just say that it would take theta n square time because you're recursive equation is tn equals 4t of n over 2 plus the linear time that you take for addition.

So this is tn equals 4t of n over 2 plus theta n. And you're assuming that the additions here take linear time. So that's how you get your theta n square algorithm. And we're not happy with that. We'd like to do better. And so how do you do better?

Well, there's many ways of doing better. The simplest way off fairly, substantially lowering the complexity is due to a gentleman by the name of Karatsuba. This is one of those things where if you were born early enough you get your name on an algorithm.

And what happens here is, using the z's that I have out there, you essentially say, look, I know z0 equals x0 and y0, I'm going to go ahead and multiply. z2 equals x2 and y2, go ahead and do that. And now I'm going to write z1 as x0 plus x1 times y0 plus y1 minus z0 minus z2. So you're actually computing z0 and z2 first, and then using them to compute z1.

So someone tell me why this is interesting? And just take it all the way to the complexity of an algorithm. Explain to me why this is interesting and why Karatsuba's algorithm has-- I'll give it away-- a lower complexity than theta n square? But tell me what it is. Someone? Someone other than you. Someone way at the back. Yup. Out there.

AUDIENCE: It's n to the log base 2 of 3.

PROFESSOR: n raised to--

AUDIENCE: Log base 2--

PROFESSOR: --log base 2 of 3. That's exactly right. And now, why did you get that? Explain to me how you got there.

AUDIENCE: If you're using three products--

PROFESSOR: That's right. So first insight is that we're only doing three multiplications here. Additions are easy. And we're doing three multiplications as opposed to four. So tell me how that equation changed, of tn. tn equals--

AUDIENCE: 3 [INAUDIBLE].

PROFESSOR: 3 times t of n over 2 plus theta n because you're doing three multiplications rather than four. Multiplications are the complicated operation. Divisions are even more complicated, but additions are easy, and you could do those in linear time for n-digit numbers.

And so, if you do that and then you go off and you say, well, that tells us that tn equals theta of n raised to log two of three, which is, by the way, theta of n raised to 1.58, roughly speaking. And I do not want to compute that to arbitrary precision, though I could. But that goes on and on. Why don't you grab this after you're done. But that just goes on and on. 1.58 is a rough approximation. That's an irrational number too, assuming you think that irrational numbers exist. That's an irrational number.

So good, that's really all I had. By the way, it's 1.58490625. I really should have written that down. 1.58-- in the context of this lecture I think it's important that we get at least a few digits a precision.

Now you can imagine that you could do it better than this. And it turns out that-- we'll talk a little bit about this next time-- But you can imagine breaking this up into not n over two chunks, but n over three chunks. Why don't I just break up x into the top third, the middle third, and then the bottom third, and then try and see if I can get away with fewer than eight multiplications? Because the original thing would have taken eight, and if I can do less than eight, maybe I can reduce that 1.58 number. So that's a little bit of a preview for what we'll do next time.

But what I'd like to do is do a demo. And I want you to run that-- it's out there so blank that out for a second. What I'd like to do is really look at a different problem than square root of 2, and show you a demo of code that Victor wrote that computes this particular quantity that, you would argue, is irrational, to arbitrary digits. Though we'll probably only go up to about a thousand today.

And if we just look at-- root 2 is kind of boring, right? It's been around for a while. Let's go back and remember high school geometry. So I think your high school teachers would like this lecture. Nice little review.

So what is that about? That's supposed to be a circle, I think, as you've forgotten. That's supposed to be a circle. And the circle here is a really big circle. It's a trillion units long. I'm into big numbers today, big numbers.

And the center of the circle is c, c for center. That is what's called a radius, in case you'd forgotten. And that's b. And this is also a radius, and that's a.

And what I'm going to do is I'm going-- I want to make a drop a little, I guess, perpendicular down, which is one unit high. So the way that this is structured is that this is one unit high, this obviously is-- someone tell me what that is, CB.

AUDIENCE: [INAUDIBLE].

PROFESSOR: Half a trillion. That's half a trillion. And obviously, CA is half a trillion. And if I call this D, somebody who remembers high school or middle school geometry give me an equation for AD. And that's definitely worth a cushion. so what's an equation for AD guys? Yeah. Go ahead.

AUDIENCE: The radius, half-trillion minus the square root of--

PROFESSOR: Square root of-- Yeah?

AUDIENCE: Minus the square root of [INAUDIBLE] square minus 1?

PROFESSOR: Perfect, perfect. OK good. So AD equals AC minus CD, and that is going to be half a trillion-- that is 500 billion, a little bit less than bailout money, but it's close-- 500 thousand minus square root of 500-- this, when you start squaring this, of course, is not even real, real big money. But 500 thousand squared minus 1. So forget the square root of two. You can put the screen down. So is it on, the projector?

AUDIENCE: It's on, it just needs a [INAUDIBLE].

PROFESSOR: OK. You can turn that on.

AUDIENCE: Rolling.

PROFESSOR: So what we're going to do is, I'm just going to show you the digits of this crazy quantity being computed to tens of thousands of digits. And you argue that this is it something clearly that isn't a perfect square. You took a perfect square, subtracted 1 from it, and so you have an irrational quantity that is going to go on and on. And let's see what that number-- what it looks like. OK?

Get out of the way. I hope you can see from the back.

AUDIENCE: Oh man, really?

PROFESSOR: Looking pretty good so far, looking pretty good.

AUDIENCE: That's crazy.

PROFESSOR: Somebody see the numbers somewhere else? Have you see these numbers before? Like 20 minutes ago, like right in front of you? OK All right.

So I think that's a good place to stop. If you want an explanation for this I think you can go to section tomorrow. I'm going to use a some attendance tomorrow. All right. Happy to answer questions about the rest of the lecture, and thanks for coming.