Name: 講義4A：パターンマッチングとルールベースの置換 (Lecture 4A: Pattern Matching and Rule-based Substitution)
Uploaded: 2021-01-14T10:27:17.000Z
Duration: 1 h 3 min 10 s
Description: VoiceTubeの動画で発音を聞きながら英語表現を覚えよう！学べる英語：

PROFESSOR: Well, yesterday we learned a bit about symbolic

過去形

manipulation, and we wrote a rather stylized program to

命令形

implement a pile of calculus rule from the calculus book.

Here on the transparencies, we see a bunch of calculus rules

And, of course, what we did is sort of translate these rules

But, of course, that's a sort of funny strategy.

Why should we have to translate these rules into the

It was a conditional, a dispatch on the type of the

What we see here are rules that say if the object being

the derivative is being taken of, if that expression is a

If it's a product of a constant times a variable, do

There's sort of a dispatch there on a type.

Well, since it has such a stylized behavior and

structure, is there some other way of writing this program

If you look at these rules in detail, what you see, for

example, is the rule has a left-hand side and a

Each of these rules has a left-hand side and the

The left-hand side is somehow compared with the expression

The right-hand side is the replacement for that

So all rules on this page are something like this.

I have patterns, and somehow, I have to produce, given a

A pattern is something that matches, and a skeleton is

something you substitute into in order to get a new

So what that means is that the pattern is matched against the

expression, which is the source expression.

And the result of the application of the rule is to

produce a new expression, which I'll call a target, by

What I'd like to do today is build a language and a means

of interpreting that language, a means of executing that

language, where that language allows us to directly express

And what we're going to do is instead of bringing the rules

to the level of the computer by writing a program that is

we're going to bring the computer to the level of us by

writing a way by which the computer can understand rules

This is slightly emphasizing the idea that we had last time

that we're trying to make a solution to a class of

The problem is if I want to write rules for a different

piece of mathematics, say, to simple algebraic

simplification or something like that, or manipulation of

trigonometric functions, I would have to write a

different program in using yesterday's method.

Whereas I would like to encapsulate all of the things

that are common to both of those programs, meaning the

idea of matching, instantiation, the control

structure, which turns out to be very complicated for such a

thing, I'd like to encapsulate that separately from the rules

So let's look at, first of all, a representation.

I'd like to look at a representation of the rules of

calculus for derivatives in a sort of simple language that

Now, I'm going to avoid--I'm going to avoid

We can easily pretty this, and I'm not interested in making--

This doesn't look like the beautiful text set dx by dt or

Here, we're just worrying about the fact that the

structure of the rules is that there is a left-hand side

here, represents the thing I want to match against the

This is the representation I'm going to say for the

derivative of a constant, which we will call c with

respect to the variable we will call v. And what we will