What we're going to talk about today, is goals.
So just by way of a little warm up exercise, I'd like you to look at that integration problem
over there. The one that's disappeared.
So the question is, can you do it in your head? Probably not. The question is, if a
program can do that, is a program, in any sense of the word, intelligent? That's a background
task I'd like you to work on as I talk today.
So today we're going to be modeling a little bit of human
problem solving, the kind that
is required when you do symbolic integration. Now, you all learned how to do that. You may
not be able to do that particular problem anymore, but you all learned how to integrate
in high school 1801, or something like that. The question is, how did you do it, and is
the problem solving technique that we are trying to model by building a program that
does symbolic integration, is that a common kind of description of what people do when
they solve problems.
So the answer to the question is, yes. The kind of problem solving you'll see
today is like generating tests, which you saw last time. It's a very common kind of
problem solving that we all engage in, that we all engage in without thinking about it,
and without having a name for it.
But once we get a name for it, we'll get power over it. And then we'll be able to deploy
it, and it will become a skill. We'll not just witness it, we'll not just understand
it, we'll use it instinctively, as a skill.
So there you are, you've got that problem, there's your problem, and what do you do to
solve it? I don't know, look it up in a table? You'll never find it in a table because of
that minus sign and that 5. So you're going to have to do something better than that.
So what you're going to do, is what you always do when you see a problem like that. You try
to apply a transform, and make it into a different problem that's easier to solve. And eventually,
what you hope is that you'll simplify it sufficiently, that the pieces that you've simplified to
will be found in some small table of integrals. So how long is this table? It's not the case
that we're going to look at a table with 388 elements, because this is not a big table
of integrals. This is what a freshman might have in a freshman's head, after taking a
course in integral calculus.
One of the interesting questions is, how many elements have to be in that table to get an
A in the course? We're interested in how much knowledge is involved, that's one of the elements
of catechism that I've listed over there, that will be part of the gold star ideas suite
of the day.
So we'd like to take that problem, and find a way to make it into another problem that's
more likely, or closer to being found in the table. So what we're going to do is very simple,
graphically. We're going to take the problem we're given, and convert it into another problem
that's simpler. And we're going to give that process and name, and we're going to call
it problem reduction.
And so, in the world of integral calculus, there are all sorts of simple methods, simple
transformations, we can try that will take a hard problem and make it into an easier
problem. And some of these transformations are extremely simple and always safe. Some
of them are just, well let's try it and see what happens. But some of them are safe, and
I'd like to make a short list of safe transformations right now.
Now I'm going to be going into some detail. And that detail will be grungy. And the question
is, why do I do it? And it's educational philosophy, is why I do it. So here's the educational
philosophy. At one level, you want to have a skill. But if you're going to have a skill,
you have to understand it. So if you're going to have a skill you have to understand it
one level down. If you're going to understand it, you have to have witnessed it on a level
lower than that.
So I'm not just going to talk about the idea of problem reduction, because if I were just
going to do that, then we could all go home now. So I'm going to show you a particular
example of it, so you understand it better, and I'm going to show you the detail at an
even lower level than that. So you will witness the stuff that makes it possible, to understand
the stuff that makes it possible, to build a skill. So that's why I'm going through the
grungy detail.
So I don't know, let's see. Maybe we can get some hints from that example, but I wonder
if somebody could volunteer a simple transformation that always is a good thing to do. Yes, Sebastian.
AUDIENCE: Take the constants out.
SPEAKER 1: Take the constants out. So we'll make that number two. And we'll say that the
integral c f of x dx is equal to c times the integral f of x dx. Other suggestions? Yes.
AUDIENCE: Trig substitution.
SPEAKER 1: Trig substitution. Now this is-- no, that's for day two. We don't do trig substitution
here under stuff that's safe, always works, never any doubt, there are simpler things.
These are the safe transformations. What you're giving me is a heuristic transformation. Often
is helpful, doesn't necessarily always work. We're going to divide our transformations
into those two categories. So I need another safe one.
AUDIENCE: [INAUDIBLE]
SPEAKER 1: The architects are sitting over there. Divided not only by nationality, but
by course. What?
AUDIENCE: The sum of integrals is the integral of the sum.
SPEAKER 1: The sum of integrals is the integral of the sum. Now what's missing? What's number
one? You're probably thinking it's already there, because you've given me the transformation
that involves a constant. And you can think of minus 1 as a constant.
But whether you use a separate transformation or not, of course depends on how you represent
the knowledge. And all of this knowledge, all of this whole thing, was written in an
early form of Lisp. As a consequence, the way in which minus was represented is different
from the way minus 1 is represented. So we need one more transformation. Or rather, Jim
Slagle needed one more transformation, when he wrote his famous transformation program.
And that was that if you have the integral of minus f of x, that's equal to, minus the
integral of f of x.
So that almost completes our safe transformation set. There's one more that I'm going to supply
you, because I don't think you'd guess it. Why should you? It's number four. There are
more than this, this is a sample. And these are the ones we're going to need in order
to solve that problem, by way of illustration.
So the fourth one is that, if you have the integral of p of x, over q of x, then you
divide. If you can reach way back into high school and figure out how to divide polynomials.
But if the degree of the numerator is greater than the degree of the denominator, then it's
a knee-jerk always win, you must do it, divide it out.
So this, then, forms the core of an integration program, that will integrate almost nothing.
But actually, almost nothing is integrable anyway, so it's a good head start. So let's
see how we would put this into some kind of procedure. Some kind of framework for deploying
the knowledge that we're beginning to develop.
What we're going to do is, apply all safe transforms. That's our first step. Then we're
going to look in the table, and then we're going to do a test to see if we're done. And
if we are, we report success. But, we're not likely to get done with just that stuff.
But you know what, there was one transformation up here, which breaks my little diagram. Which
one is it? It's the third one, right? Because this picture does not reflect what happens
when you apply number three. Because it breaks the problem up, not into just one problem,
but into a whole bunch. So we have to extend our graphical device for talking about this
by a little bit, and show what is called an "and node".
So we've got a program core, we've got a table of integrals, we've got a few transformations,
we've got an architecture, a way of putting that stuff together. And now we can try it
out on our sample problem. So let's have a go at that.
Let's see, this one immediately transforms into 5x to the fourth over 1 minus x squared
to the 5/2 dx. And that in turn, immediately transforms into the integral of x to the fourth
over 1 minus x squared to the 5/2, dx.
This program, by the way, is a dawn-age program. This was written by a nearly blind, and subsequently
completely blind, graduate student by the name of James Slagle in 1960, a long time
ago. The reason I gave it to you today is because, that by describing it, I am giving
you a one-lecture course in artificial intelligence. He anticipated so much of the subsequent 20
years, that talking about his program, which is possible in one day, is a miniature introduction
to the whole field.
So Slagle, as he was doing this on an antique computer, almost no memory, almost no speed,
only slightly faster than mice running around on a treadmill. He was able to write a program
that did extremely well when benchmarked against freshmen. And the way you benchmark against
freshman, of course, is you give it an examination, drawn from the previous MIT finals for four
or five years, the hardest problems. And this was the hardest problem that it solved.
So at this point, with what we've got so far, we would be stuck. We have no transformation
that can take us further, so we need something else. And what we need by way of something
else, is some transformations that we will describe as-- perhaps we'll call them, heuristic
transformations. A funny word, meaning a method that often works isn't guaranteed to work.
It's not an algorithm in the usual sense that we talk about algorithms. But rather, it's
an attempt.
So these things I'm going to talk about now, are sometimes useful, not always useful. Sometimes
take you into a blind alley, don' always work. But you can't get an A in calculus without
knowing some of them. So you said, some kind of trig substitution. So here is some kind
of trig substitution. We'll call this heuristic transformation A.
You have a function sine x, cosine x, tangent of x, cotangent of x, secant of x, and cosecant
of x. And we all know from high school trigonometry, that we can rewrite that as a function of
sine x, and cosine x. Or we can rewrite that as a function of tangent of x, and cosecant
of x. Or we can rewrite that as function of cotangent of x, and the secant of x. So that's
a transmission from trigonometric form, into another trigonometric form. It's not always
a good idea, sometimes it helps.
Well that's just part one of our suite of heuristic transformations. Stop. There are
others that we need to have in our repertoire, in order to solve the problem. One of them
is a family of transformations, which I'll show you only one. It goes like this, if you
have the integral of a function, of the tangent of x, then you can rewrite that as the integral
of a function of y over 1 plus y squared dy. So that's a transformation from a trigonometric
form into a polynomial form. So it gets rid of all that trigonometric garbage we don't
want to deal with. And there's a whole family of things like that, just as there's a family
of transformations like so, but this is enough to give you flavor.
Now there's a C that we need as well. And that's going to be your proper knee-jerk reaction
when you see something of the form 1 minus x squared. What do you do when you see that?
AUDIENCE: [INAUDIBLE]
What's that Rhana?
Rhana: 1 + 6 * 1 - 6
Well wait a second. We could do that. But there's another thing we can do.
Christian, have you got something you can suggest? Where's our Hungarian? Our Turk,
our young Turk. Yeah, what do you think?
AUDIENCE: I actually don't remember. I mean, I think it might have been 10.
SPEAKER 1: Well, let's see. Cosine squared plus sine squared equals 1. So, what's that
suggest to you? So it suggests that we make a transformation that involves x equals sine
y. So [? Silla ?] doesn't actually have to remember that anymore because going forward,
she will never have to integrate anything personally in her life, she can just simulate
the program.
So these go from polynomial form, back into trigonometric form. So you have three of these
heuristic transformations. We've got four safe transformations. Let's see if we can
make any progress on our integration problem.
OK so keeping track of what we've been using, this is safe transformation number one, this
is safe transformation number two. What do we do next? We decided there were no more
safe transformations that apply. But now we can look at our heuristic transformations
and behold, we see what?
AUDIENCE: C
SPEAKER 1: What?
AUDIENCE: Applying transformation C.
SPEAKER 1: Transformation C suggests that we do x equals the sine y.
And now we get the integral of sine to the
fourth y over cosine to the fourth y dy, right. All good, I see some confused, worried, concerned
looks. Maybe I've made a mistake, perhaps I should use notes. Well no, wait a minute.
For those of you who have a concerned look, remember that if x equals a sine y, then dx
is equal to cosine y dy. That's why it's cosine to the fourth not cosine to the fifth, as
you were perhaps thinking it might be.
So now we've made some progress. We look at this, we say, are there any safe transformations
that apply? And the answer is, no. Now we look for a heuristic transformation that might
apply, and I say, what do you see? Which one? What's that?
AUDIENCE: [INAUDIBLE].
SPEAKER 1: She said something unintelligible, but what she probably said is, that this looks
like a pattern that might match with the heuristic transformation A, right? Because we have a
function in which the variable is buried, universally in sines, or cosines, or tangents,
or cotangents, or secants, or cosecants. And we know we can rewrite that in one of three
ways. It's already written as a function of sine and cosine. But we can also rewrite that
in terms of tangent and cosecant. Or cotangent and secant.
So when we do that, we can go this way, and we can get the integral of 1 over the cotangent
of x dx. That's g3 up there. Or we can do it down this path, and get the integral of
tangent of x dx. And of course, those are both to the fourth.
But know what, I've broken my little graphical diagram again. Where did it go, it's disappeared.
There it is. How have I broken it? Because with transformation A, I've introduced a possibility
that a particular problem can be transformed into more than one kind of problem, any of
which will be the solution to my problem.
So far I've got an and node, but now I've got to introduce an or node. Because now we
have an example of something that can be solved one of two different ways, and we don't care
which one it is. Now you'll notice that there's already some confusion here, because how can
you tell the difference between an and node and an or node. So the universal convention
is, you draw an arc over the and nodes. And that makes it look like an A, so it's easy
to remember. So those are and nodes.
And now, we have the method of problem reduction, and this is sometimes called a problem reduction
tree. Sometimes it's called an and/or tree, and sometimes it's called a goal tree, because
this tree of problems is a tree that shows how our goals are related to one another.
So these are items for your vocabulary that are all synonymous. Problem reduction tree,
and/or tree, goal tree, all the same thing. Now you have a name for it, you've got some
power over it. So when we get a situation like this, unlike the previous situation,
which we suggested might come up in transformation A. Let's see, we've got one, two, C, and this
one is A, it's an or node. Which one of these problems do we work on?
Well Slegle, who considered himself to be modeling a freshman, modeling the intelligence
of a freshman, modeling something that, after all, you have to be pretty smart to do, right.
Most people don't know how to do integration. Everybody at MIT knows how to do integration.
You would think that somebody, therefore, that knows how to do integration is pretty
smart. What would a smart person do, when faced with this choice?
Well, a smart person would say, which of these two problems is easier? So how do you think
you might determine which of two, or many algebraic expressions is the easiest to integrate?
What's your name?
AUDIENCE: Andrew Carrol.
SPEAKER 1: Andrew, what do you think?
AUDIENCE: Based on whichever one feels more familiar.
SPEAKER 1: Feels.
AUDIENCE: Yes.
SPEAKER 1: Feels.
AUDIENCE: You asked, how would I decide.
SPEAKER 1: Yeah, how would you decide? How would you feel it?
AUDIENCE: I would feel that the tangent is more familiar.
SPEAKER 1: Which one?
AUDIENCE: I feel that the tangent [INAUDIBLE].
SPEAKER 1: Yeah, but I wonder how we could make it a little bit more precise, this idea
of simplicity. The young Turk has a suggestion. What?
AUDIENCE: I had a suggestion until you said this idea of simplicity. So then I realized
that what I was about to suggest wasn't going to clarify simplicity, but I was going to
say, whichever one we've had more encounters with, or more experience with.
SPEAKER 1: Yeah, if there was something here with a hyperbolic tangent, you might say,
well, stay away from that. [? Yinid ?]?
AUDIENCE: To which one of those the easier transformation is applied on the next step.
SPEAKER 1: Like, somebody do a little look ahead, and see which kind of thing would be
next to you? I don't know, maybe. Oh, we've got lots of people, all at the same time.
I don't know all your names yet. Shoot. Erica, I know you.
AUDIENCE: What's look it up in the table and see [INAUDIBLE].
SPEAKER 1: Oh, you could look it up in the table and see if something is in it, you could
do that. But this is tangent to the fourth, so that's not in the table. Ariel?
AUDIENCE: I choose the one without the reciprocal.
SPEAKER 1: Why?
AUDIENCE: It is because when people see one it's like, oh man, it jut not going to work.
SPEAKER 1: Yeah, we're on the right track. Claire?
AUDIENCE: On an extremely simple level, I choose whichever one has the least symbols
in it.
SPEAKER 1: The fewest symbols in it. Now we're really getting somewhere, because you can
measure that, right, there's a little program Why Brett, there you are.
AUDIENCE: I would say, every [INAUDIBLE] expression can be written as, having a number of functions,
we could say all these functions, multiplied together, divided, and you can just choose
with the least amount of [? iterations ?].
SPEAKER 1: Well I heard it, perhaps others didn't but what Brett said, is he suggested
that we should measure depth of functional composition. So the number of symbols may
not matter, because if you have x plus x plus x plus x, out to a hundred, that would not
be hard to integrate. But if you've got something that is really deeply nested under a lot of
functional compositions, that could be a problem. And that's in fact, what Slegle decided to
use, after trying several alternatives.
So if we measure the depth of the functional composition, this is the winner, and we put
the other one on the shelf, at least for the moment. And now we have tangent to the fourth
x dx. Do I need the safe transformation supply? No. Which of the-- you know something has
to apply, otherwise it wouldn't be up here as an example. So what of the heuristic transformation
supply? Elliott.
AUDIENCE: [INAUDIBLE]
SPEAKER 1: Yeah, B bravo. Military background or something like that. Maybe
he flies airplanes. OK so B says, it is in fact a function of the tangent. And when we
do that, we've got to make a substitution, that y is equal to the tangent. So that means
that this becomes the integral of y to the fourth over 1 plus y squared. And that's by
transformation B, and the transformation is y equals tangent of x. The tangent-- I guess
I've lost track of the fact that I've already transformed a y, but relabeling doesn't matter.
All right so that's progress, maybe. But don't see this in any of the heuristic transformations,
what do I do now? I didn't have to look in the heuristic transformations, because one
of the safe transformations applies. Because this thing is a rational function and the
degree of the numerator is greater that the degree of the denominator, so I have to divide.
And when I divide, and that by the way is number four, I get what? Is anybody good high
school algebra that can help me out with that?
AUDIENCE: Y squared minus 2 plus negative 2 over 1 plus y squared
SPEAKER 1: Exactly, y squared minus 1 plus 1 over 1 plus y squared, I think. Now what?
Now we're really getting close to getting through this, because that is a sum. And by
virtue of the fact that it's a sum, that divides into three pieces, and the top piece is the
integral of y squared, the middle piece is the integral of minus 1, and the bottom piece
is the integral of 1 over 1 plus y squared dy in all cases.
Gosh, if I look this up, I've found it. That's up there, that's letter B. So I'm done with
that. This one I can transform again, by virtue of 1, and now I get the integral dy. That's
in there, that's B as well. As this one, I don't know. But I'd better keep track of what
I'm doing here. This is in the and node, so I've got to do all of those. I can't give
up on that last thing. And that and transformation is transformation number 3. So this is in
the table, this is in the table, we still have this to do, but that's C, heuristic transformation
C. We have 1, plus y squared, then with the transformation C, with y-- this is y squared--
y equals tangent of z And then we get to the integral of dz and that's in the table and,
we're done.
So now we've solved the problem. It's the hardest problem that appeared in that half
decade on MIT 18 01 finals. This is exactly the problem that was given, except that it
started here. I put the other two pieces on just to illustrate a couple of the transformations.
But that's a problem that it solved.
And now that we've seen an example, we can finish up what we talked about a little bit
ago, having to do with the architecture of this thing. So far, all we've done is talk
about the safe transformations, but now we know that if we're not done, we need to find
a problem to work on
using that depth of functional composition business. And then after that we apply heuristic
transformation.
And the way Slagle designed his program is,
he found just one problem to work on, did one transformation,
then went back around the loop. Because these heuristic transformations are a little harder
to apply than the safe ones. So I'll given you an accurate portrayal of what this program
did, except for one thing. Which I would like, now, to go back and patch up. And that thing
is over here. What to do with something like this. Well we got to that in a board that's
disappeared, but when we tried to deal with this, we had to find a heuristic transformation.
And when we decided to work on this, it must have been the case that this was the simplest
problem at a leaf node that has not yet been solved.
So what's the functional composition depth of this? It's 3. Back over here, we have something
that has a depth of functional composition of 2. So when the program actually ran on
this particular problem, it stopped a few inches short of the finish line, And went
back and screwed around with that other problem for a little bit, before it gave up and came
back here.
So it's always looking across the whole tree, the leaves of the tree. Whenever it has to
find a place to work on with the heuristic transformation, it happened to look at all
the leaves of the tree that had not yet been dealt with, tried to find the easiest one,
and that could involve a lot of backing up and starting over on a branch of the tree
that it had previously ignored. A small detail, not a particularly important one.
Now where are we. We've got that guy there. We've got our complete architecture. We've
got our solved problem. And now we can start reflecting on what we've done. We can say,
for example, how good an integration program is this? And the answer is, it was pretty
good. This machine that Slagle was using was a machine that was over in building 26. And
we were so proud of it, that it was behind glass, and you could go there and watch the
tape spin, it was really a delight. 32k of memory, that's 32k of memory. It's amazing
that he was able to do anything with a machine of that size.
Let's see, let's get us a clean one. Can't do board geometry and talk at the same
time. We can now ask some questions about how well the program performed. It was given
56 of the hardest problems, and it got 54 right. What happened when it didn't get the
other two? Well, you might be right if you said, oh it probably ran out of memory, since
it had 32k. But in fact, it just was lacking 2 transformations that were needed, in order
to solve the whole entire set of final quiz problems. So when a program fails, that's
often the most interesting question you can ask. This is an exception. This failed for
uninteresting reasons on 2 of the 56 problems that it was given to.
And now the next question you can say is, what is the depth of the tree in the maximal
case? And the answer is, it's that case we just worked out. And since I've once again
lost the whole tree, I'll tell you that it's depth was 7 when you take off that minus 5.
So in the worst case, this thing had to get down seven levels.
That's the worst case, a more interesting question is what was the average depth? And
that was approximately 3. And now we're beginning to say something, not only about Slagle's
model of how a freshman works, but we're beginning to say something about the nature of the domain.
In the domain of calculus problems, integrals expressions that are given to freshman, in
that domain, the average depth of problem reduction needed to solve the problem was
3. So that's not very complicated. If it were 10, you would say, wow, how can anybody ever
do those problems? If it were 5, you'd say, well only people destined to be math professors
are going to get anything right. If it's 3, us ordinary mortals can do a pretty good job.
Another question of even greater interest is, how many branches were unused? Here's
a branch that turned out to be unused, it didn't pursue that. And so you might say,
well maybe there are a lot of unused branches. Maybe you have to be pretty smart about your
method for determining what problem to work on, because otherwise you'll go down a lot
of rat holes.
And guess what, here's another statement about the domain. In the domain of problems that
freshmen could work on a final, the number of unused branches is about 1. So that means
this tree keeps itself together, and doesn't run down to a very large, bushy, useless tree.
So this means that the depth of functional composition, which Brett suggested as a technique
for recognizing the right problem work on, was a choice that didn't actually matter.
Because the tree doesn't grow deep, it doesn't go broad. It doesn't matter what you use to
decide what to work on, because in the worst case, you'll just generate a couple of extra,
useless nodes. But they very quickly run to find a dead end, so you don't have to do anything
more with them.
So now the next thing we need to do is back even further away from this program, and ask
ourselves some questions about the nature of what we've been doing. And that brings
me to the things I've got on that upper right-hand board. One of those things as a catechism
having to do with knowledge.
And what we've done informally as we went through this program was, we've asked questions
such as, what kind of knowledge is involved in doing this? Well knowledge about transformation.
Knowledge about how goal trees work and when we're done with a problem. Knowledge about
what things don't need to be transformed, because you can look them up in a table. That's
the kind of knowledge that is involved in doing 18 01. And if you do 18 0 circuit theory,
6 0 circuit theory or 6 0 Maxwell's equations, this is the same thing.
You have to ask questions of this sort,
about the nature of the knowledge involved, and question number one is always, what kind
of knowledge is involved? Is it Kirchhoff's laws, Maxwell's equations, what is it?
The next question is, how is the knowledge represented? And our answers here are, well
all this stuff, ultimately was represented in list best expressions. Some of the
knowledge was recorded in a table [? of best ?] expressions to show what transformations
there are. There was a similar table of integrals. Knowledge about goal trees was embedded in
the procedure, so it was procedurally represented. And so for each of the categories of knowledge,
there's a way it gets represented. How is it used? Straightforward, transformations
are used to make the problem simpler. The table is used to trim off and to serve as
the bottom of the tree. Those are the ways in which the knowledge is used.
And then there's the question of course of, how much knowledge is required. Something
that's useful to know if it's late at night, you have 2 finals the next day, and you're
not sure which course you should study. So how much knowledge might you suppose was actually
in this program? I've shown you a glimpse of the kind of knowledge that's involved in
the program. I've answered a little bit of question 5, what exactly. But how much knowledge
was involved. You might be surprised by the answer.
First of all, the table of integrals. I've listed only 3 things there. There are lots
of other things you can think of, like integral of e to the x is e to the x. But in the end,
what Slagle found is, a table only 26 elements was enough to solve all of these problems.
How about the transformations here, the safe ones, about 12. How about the heuristic ones,
about 12. So just a few bits and pieces of knowledge, here and there, are sufficient
to do everything you need to do, in order to do the integration problems on a calculus
final. That was a surprise.
Another surprise of a similar kind, also about knowledge, is that the relationship between
the method to be used, and the characteristics of the problem, was almost a diagonal table.
That means that you could, in this domain, make the right transformation almost all the
time if you're a little bit smart, and never back up. That was an observation made by Joel
Moses, who became subsequently our provost here at MIT for a while. And he wrote a program
that could solve anything. It would beat the most dedicated mathematicians at integration.
And its descendents are in MATLAB today.
But this is how it all works. And now you can write one of these things yourself. Partly
because you now have this catechism. This is the kind of stuff you should ask any time
you're dealing with a new domain. It will make you smarter. And this is of course, meta
knowledge, this is knowledge about knowledge. So this tired aphorism isn't quite what we
are going to complete ourselves with. We're going to say that knowledge about knowledge
is where the real power is.
Now there's one final thing that this program does for us. It tells us something about our
appreciation of what it means to be intelligent. You know that in the beginning of this hour,
I asked you to think about whether a program that could do symbolic integration would be,
in any way, or should be considered to any degree, intelligent. And I'm imagining that
even in these days of MATLAB, and whatnot, many of you said well, yes, I learned how
to do that at MIT, or late in high school, so it must be smart.
But now that we've completed this discussion, I also expect that your feeling of intelligence
in this program is somewhat diminished. Because what happens is that, when we understand how
something works, it's intelligence seems to vanish. You've seen this in your friends,
right? They solve some problem, they seem super smart. Then they tell you how they did
it, and they don't seem so smart anymore.
So let's conclude our discussion today was a little story. A long time ago I was talking
with a student who said, computers cannot be intelligent. And I said, OK, maybe you're
right, but let me show you this program. So I showed him the integration program, working
on problems like this. And after I showed him a couple of those examples, he says, well,
all right, I guess maybe they can be intelligent. I'm learning how to do that, and it's not
always easy. Then I made a fatal mistake. I said let me show you how it works, and we
spent an hour going through it like this. And at the end of that time, he turned to
me and said, I take it back, it's not intelligent after all. It does integration the same way
I do.