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.
All right.
I'll start giving you some hints here.
f of xi plus-- plus--
ALL: f prime.
PROFESSOR: f prime xi.
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.