kanishka/counterfactual-babylm-keys_to_it_all_removal

text stringlengths 2 21.4k
let's say, five, six, seven, eight, and one, two, three, four .
Now, as you'll recall, the procedure we learned way back when was just to take each digit of the bottom number and multiply it by each of the top numbers.
So, for example, you start with the four.
You multiply it by eight, so you get 32.
Carry the three.
four times seven is 28, add the three, you get one, carry the three, and so on.
Then, you do a shift, so you effectively put a zero in this final digit, and you repeat that procedure using the next digit, the three.
So again, three times eight is four, carry the two, and so on.
And you compute the final two partial products using the two and the one.
And having computed all of the partial products, you just add them up to get the final product.
And more generally, how many does it require to multiply two n digit numbers as a function of n.
So, just in ballpark terms, it seems that multiplying two n digit numbers required essentially a quadratic number of operations, a small number of operations to fill in each entry in this grid.
In a little more detail, we could look at each of the partial products separately.
So, to compute, say, this first partial product, what do we do?
But, in the end, we did somewhere between, say, n and the 2n, primitive operations to compute this first partial product.
So, that's roughly n operations for each of the n partial products .
It could be all of the partial products.
But that takes just an extra number of constant times n primitive operations to do all of those additions.
So summarizing, overall, the number of primitive operations required to multiply to n digit numbers using this procedure grows quadratically with the length N. So, for example, if you double the length of two numbers, you expect to do roughly four times as many primitive operations if you use this iterative algorithm for multiplying two numbers.
Now, depending on what type of third grader you were, you might well have accepted this procedure as being the unique or at least the optimal way of multiplying two n digit numbers together.
It's from a quite early textbook in the field The Design and Analysis of Computer Algorithms by Aho,
Hopcroft, and Ullman, and after highlighting a number of algorithmic design techniques, they conclude by saying, perhaps the most important principle for the good algorithm designer is to refuse to be content."
So, that's a beautifully accurate quote.
I might rephrase it more succinctly by just saying, if you're, want to be a good algorithm designer, you should adopt the following mantra.
You should always be asking, can we do better?
This is particularly appropriate question to ask when you're faced with some kind of naive or obvious algorithm for solving a problem, like the third grade algorithm for energy multiplication.
There'll be an obvious solution but with some extra algorithmic ingenuity by detecting subtle structure in the problem, we'll be able to do signifigantly, qualitatively better than the naive or the obvious solution to the problem.
So, let's apply this cocky attitude to the problem of multiplying two in tegers.
Let's just take, suppose as a working hypothesis that there is some procedure which is better than what we learned back in elementary school.
But they're also recursive programs.
These are programs that call themselves, typically, on an input of a similar form, but with smaller size.
So, as a working hypothesis,
let's imagine that there's some interesting recursive approach to multiplying two integers.
Well, it must somehow fundamentally involve calling itself on smaller problems.
So, what kind of decomposition on numbers could be used to enable this kind of recursive approach?
And the second half of the digits, regard that as a number in its own right.
So, perhaps this decomposition will have some use, in enabling a recursive attack on how to multiply two images.
So, we're going to investigate that in more detail on this next slide.
Given x and y, each with n over two digits, we're going to represent x as terms of its first half of the digits a and its second half of the digit to b.
And in this expansion, a and b, c and d are all n over two digit numbers.
This will extend to the case where n is odd in the natural way, where you break it into n over two rounded up and n over two rounded down.
So, in our previous example, where x was 5,678 and y was 1,234, we would have a being equal to 56 .
The first two digits of the four in x.
And then b would be the other two digits.
They have decomposition of y.
So now, in a purely mechanical way, we can expand the product of x times y in terms of this representation.
In terms of these smaller numbers, a, b, c, and d.
So, that's combining two terms from the expansion, plus bd.
Now, what I want you to think about and make sure you understand is that, this expansion that I've circled and called star, immediately suggests a recursive algorithm for multiplying two integers.
But certainly, it's a legitimate recursive approach to multiplying two integers.
Specifically, the relevant product in star namely ac, ad, bc, and bd all involve smaller numbers than what we stared with.
Those all original inputs at n digits so we can legitimately solve those recursively.
We can invoke our same algorithm to compute those in a recursive way.
Now, once we've invoked our multiplication algorithm recursively four times to compute these four relevant products, now we can just compute the expression in star in the obvious way.
We take ad and bc.
We add them together, using the just, standard first grade iterative addition algorithm.
Then, we add both ac and the result of that addition by a bunch of zeros, n over two zeros or n zeros as appropriate.
Now, we have these three constituent terms and we just add them up again using the grade school algorithms to compute the overall expression.
So, to keep this intro lecture brisk, I haven't discussed the base case of this recursive al gorithm.
As, hopefully, you all know, recursive algorithms do need base cases.
At some point, the recursion has got to stop.
Otherwise, your algorithm is never going to terminate.
If the numbers have two or more digits, you would recurse in the way we have described here.
If there's one digit, you just compute them and you're done.
So, who knows whether this recursive algorithm is a good idea or not, it's totally not obvious, you should not even necessarily have any intuition about how this compares to the iterative algorithm you learned back in elementary school.
So, to explain this algorithm, let me write once again our expansion in terms of the n over two digit numbers.
Now, the previous approach was in recognition of the four products that we see in this expression.
We made four recursive calls.
So, here's the trick, and this is really what Gauss figured out over 200 years ago which is that it seems there are four products.
But fundamentally, in this expression, there's really only three quantities that we care about.
There's the ac, the coefficient of this first term.
We really don't care about them individually.
So, that motivates the question, perhaps we can somehow uncover these three d ifferent quantities using only three recursive calls rather than four.
We go ahead and compute ac and bd recursively.
The third step is the, is the clever one where we recursively compute the product of quantity a plus b with c plus d.
Now, expanding what are we going to get when we recursively compute this product, we're going to get ac plus bd plus ad plus bc.
And here is Gauss's trick for observation which is that the result of the third recursive call minus each of the first two, what happens?
Well, the ac is going to cancel the ac, the bd is going to cancel the bd and we will be left with ad + bc, which is exactly that middle coefficience that we cared about.
So, we can indeed compute the sum of ad and bc without separately computing each of them, and that's exactly what we wanted.
So, what is this bias?
Only three recursive calls rather than four.
And as before, there's a little bit of work to do beyond the recursive calls but not much.
You just have to do some padding by zeroes and adding up the results.
So, there is two points I want you to appreciate about all these energy multiplication algorithms.
The first point is that the algorithm design space is incredibly rich.
Much richer than you might have had initially had intuition for.
Multiply two integers.
What else could you do with the elementary algorithm?
Well, what have we seen?
looks nothing like what we learned back in grade school.
We will see this over and over again, that with sufficient ingenuity, sufficient cleverness you can solve problems in ways much differently and sometimes much better than using the naive straightforward algorithm.
The second takeaway point from this discussion of in teger multiplication algorithms is that sometimes you have interesting algorithmic ideas for which it's totally not obvious what kinds of properties or what kinds of performance guarantees those algorithms enjoy.
Which of these three requires the fewest number of cumulative operations to multiply two integers?
learned back in elementary school?
The answer to that question is totally not obvious and it requires nontrivial mathematical analysis to answer.
In the upcoming lectures, I will provide you with the tools to not only precisely understand and answer this question but more generally, to predict the running times of an entire genre of divide and conquer algorithms like Karatsuba multiplication.
So, stay tuned.
i'm too weak too slow too big i ate to much for breakfast i got a headache its raining my dog is sick i can't right now im not inspired it makes me smell bad im alergic to stuff im fat im thin its too hot im not right i've got shin split a headace im distracted im exerting myself too much i'd love to really, but i can't my favourite show is on i've got a case on monday tuesday wednesday i dont wanna do this i wanna do something else after new year next week i might make a mistake i've got homework i feel blowded i have gas i got a hot date my coach hates me my mom won't let me i bruise easily it's too dark too cold my blister hurts this is dangerous uhh, sorry i dont have a bike i didnt get enough sleep my tummy hurts it's not in my genes i dont wanna look all tired now i need a better coach i dont like getting tackled i have a stomache ache im not that athletic type i dont wanna get sweaty i have better things to do i dont wanna slow you down i have to do this?
as soon as i get a promotion i think i'll skip this one out and my feet hurt!
Companies are losing control.

let's say, five, six, seven, eight, and one, two, three, four .

Now, as you'll recall, the procedure we learned way back when was just to take each digit of the bottom number and multiply it by each of the top numbers.

So, for example, you start with the four.

You multiply it by eight, so you get 32.

Carry the three.

four times seven is 28, add the three, you get one, carry the three, and so on.

Then, you do a shift, so you effectively put a zero in this final digit, and you repeat that procedure using the next digit, the three.

So again, three times eight is four, carry the two, and so on.

And you compute the final two partial products using the two and the one.

And having computed all of the partial products, you just add them up to get the final product.

And more generally, how many does it require to multiply two n digit numbers as a function of n.

So, just in ballpark terms, it seems that multiplying two n digit numbers required essentially a quadratic number of operations, a small number of operations to fill in each entry in this grid.

In a little more detail, we could look at each of the partial products separately.

So, to compute, say, this first partial product, what do we do?

But, in the end, we did somewhere between, say, n and the 2n, primitive operations to compute this first partial product.

So, that's roughly n operations for each of the n partial products .

It could be all of the partial products.

But that takes just an extra number of constant times n primitive operations to do all of those additions.

So summarizing, overall, the number of primitive operations required to multiply to n digit numbers using this procedure grows quadratically with the length N. So, for example, if you double the length of two numbers, you expect to do roughly four times as many primitive operations if you use this iterative algorithm for multiplying two numbers.

Now, depending on what type of third grader you were, you might well have accepted this procedure as being the unique or at least the optimal way of multiplying two n digit numbers together.

It's from a quite early textbook in the field The Design and Analysis of Computer Algorithms by Aho,

Hopcroft, and Ullman, and after highlighting a number of algorithmic design techniques, they conclude by saying, perhaps the most important principle for the good algorithm designer is to refuse to be content."

So, that's a beautifully accurate quote.

I might rephrase it more succinctly by just saying, if you're, want to be a good algorithm designer, you should adopt the following mantra.

You should always be asking, can we do better?

This is particularly appropriate question to ask when you're faced with some kind of naive or obvious algorithm for solving a problem, like the third grade algorithm for energy multiplication.

There'll be an obvious solution but with some extra algorithmic ingenuity by detecting subtle structure in the problem, we'll be able to do signifigantly, qualitatively better than the naive or the obvious solution to the problem.

So, let's apply this cocky attitude to the problem of multiplying two in tegers.

Let's just take, suppose as a working hypothesis that there is some procedure which is better than what we learned back in elementary school.

But they're also recursive programs.

These are programs that call themselves, typically, on an input of a similar form, but with smaller size.

So, as a working hypothesis,

let's imagine that there's some interesting recursive approach to multiplying two integers.

Well, it must somehow fundamentally involve calling itself on smaller problems.

So, what kind of decomposition on numbers could be used to enable this kind of recursive approach?

And the second half of the digits, regard that as a number in its own right.

So, perhaps this decomposition will have some use, in enabling a recursive attack on how to multiply two images.

So, we're going to investigate that in more detail on this next slide.

Given x and y, each with n over two digits, we're going to represent x as terms of its first half of the digits a and its second half of the digit to b.

And in this expansion, a and b, c and d are all n over two digit numbers.

This will extend to the case where n is odd in the natural way, where you break it into n over two rounded up and n over two rounded down.

So, in our previous example, where x was 5,678 and y was 1,234, we would have a being equal to 56 .

The first two digits of the four in x.

And then b would be the other two digits.

They have decomposition of y.

So now, in a purely mechanical way, we can expand the product of x times y in terms of this representation.

In terms of these smaller numbers, a, b, c, and d.

So, that's combining two terms from the expansion, plus bd.

Now, what I want you to think about and make sure you understand is that, this expansion that I've circled and called star, immediately suggests a recursive algorithm for multiplying two integers.

But certainly, it's a legitimate recursive approach to multiplying two integers.

Specifically, the relevant product in star namely ac, ad, bc, and bd all involve smaller numbers than what we stared with.

Those all original inputs at n digits so we can legitimately solve those recursively.

We can invoke our same algorithm to compute those in a recursive way.

Now, once we've invoked our multiplication algorithm recursively four times to compute these four relevant products, now we can just compute the expression in star in the obvious way.

We take ad and bc.

We add them together, using the just, standard first grade iterative addition algorithm.

Then, we add both ac and the result of that addition by a bunch of zeros, n over two zeros or n zeros as appropriate.

Now, we have these three constituent terms and we just add them up again using the grade school algorithms to compute the overall expression.

So, to keep this intro lecture brisk, I haven't discussed the base case of this recursive al gorithm.

As, hopefully, you all know, recursive algorithms do need base cases.

At some point, the recursion has got to stop.

Otherwise, your algorithm is never going to terminate.

If the numbers have two or more digits, you would recurse in the way we have described here.

If there's one digit, you just compute them and you're done.

So, who knows whether this recursive algorithm is a good idea or not, it's totally not obvious, you should not even necessarily have any intuition about how this compares to the iterative algorithm you learned back in elementary school.

So, to explain this algorithm, let me write once again our expansion in terms of the n over two digit numbers.

Now, the previous approach was in recognition of the four products that we see in this expression.

We made four recursive calls.

So, here's the trick, and this is really what Gauss figured out over 200 years ago which is that it seems there are four products.

But fundamentally, in this expression, there's really only three quantities that we care about.

There's the ac, the coefficient of this first term.

We really don't care about them individually.

So, that motivates the question, perhaps we can somehow uncover these three d ifferent quantities using only three recursive calls rather than four.

We go ahead and compute ac and bd recursively.

The third step is the, is the clever one where we recursively compute the product of quantity a plus b with c plus d.

Now, expanding what are we going to get when we recursively compute this product, we're going to get ac plus bd plus ad plus bc.

And here is Gauss's trick for observation which is that the result of the third recursive call minus each of the first two, what happens?

Well, the ac is going to cancel the ac, the bd is going to cancel the bd and we will be left with ad + bc, which is exactly that middle coefficience that we cared about.

So, we can indeed compute the sum of ad and bc without separately computing each of them, and that's exactly what we wanted.

So, what is this bias?

Only three recursive calls rather than four.

And as before, there's a little bit of work to do beyond the recursive calls but not much.

You just have to do some padding by zeroes and adding up the results.

So, there is two points I want you to appreciate about all these energy multiplication algorithms.

The first point is that the algorithm design space is incredibly rich.

Much richer than you might have had initially had intuition for.

Multiply two integers.

What else could you do with the elementary algorithm?

Well, what have we seen?

looks nothing like what we learned back in grade school.

We will see this over and over again, that with sufficient ingenuity, sufficient cleverness you can solve problems in ways much differently and sometimes much better than using the naive straightforward algorithm.

The second takeaway point from this discussion of in teger multiplication algorithms is that sometimes you have interesting algorithmic ideas for which it's totally not obvious what kinds of properties or what kinds of performance guarantees those algorithms enjoy.

Which of these three requires the fewest number of cumulative operations to multiply two integers?

learned back in elementary school?

The answer to that question is totally not obvious and it requires nontrivial mathematical analysis to answer.

In the upcoming lectures, I will provide you with the tools to not only precisely understand and answer this question but more generally, to predict the running times of an entire genre of divide and conquer algorithms like Karatsuba multiplication.

So, stay tuned.

i'm too weak too slow too big i ate to much for breakfast i got a headache its raining my dog is sick i can't right now im not inspired it makes me smell bad im alergic to stuff im fat im thin its too hot im not right i've got shin split a headace im distracted im exerting myself too much i'd love to really, but i can't my favourite show is on i've got a case on monday tuesday wednesday i dont wanna do this i wanna do something else after new year next week i might make a mistake i've got homework i feel blowded i have gas i got a hot date my coach hates me my mom won't let me i bruise easily it's too dark too cold my blister hurts this is dangerous uhh, sorry i dont have a bike i didnt get enough sleep my tummy hurts it's not in my genes i dont wanna look all tired now i need a better coach i dont like getting tackled i have a stomache ache im not that athletic type i dont wanna get sweaty i have better things to do i dont wanna slow you down i have to do this?

as soon as i get a promotion i think i'll skip this one out and my feet hurt!

Companies are losing control.