Now, there is a bit of a caveat to this.

And this is a little bit of an idealized situation,

but it actually is something that can lead to trouble in the real world.

So we have these two problems and we have this two propositions

that they linear-time reduce to one another.

Now, it could be that a big software engineering effort, there's a lot

of people making decisions, so we found that they have the same complexity.

But maybe some system designer has a big project and

there’s a lot of things and they need both sort and convex hull.

And one programmer is charged with the job of implementing sort and

understands it well, could do that using convexHull and learn this is a cool trick.

And the other one knows the grand scan,

It says okay, I'm going to index convexHull using sort.

And that's in a big system, and that's going to lead to a problem.

It's an infinite reduction loop, which certainly is going to lead to problems.

Whose fault?

Well, that would be the boss.

Alice and Bob just did what they were supposed to do.

And you say, well, someone could argue Alice maybe could have used the library

routine for the sort, but you get the point.

For a more complex situation, this definitely could come up.

Just to show the power of this kind of technique and

how it relates to research that's ongoing into computer science,

let's look at some simple examples from arithmetic.

So here's the grade school integer multiplication, let's do it with bits.

So I've two N-bit integers, I want to compute the product.

And this is the way you learn to do it in grade school.

For every bit in the bottom you multiply it by the top and

then you add them all together.