We've talked a lot about linear transformations.
What I want to do in this video, and actually the next
few videos, is to show you how to essentially design linear
transformations to do things to vectors that you
want them to do.
So we already know that if I have some linear
transformation, T, and it's a mapping from Rn to Rm, then we
can represent T-- what T does to any vector in x, or the
mapping of T of x in Rn to Rm-- we could represent it as
some matrix times the vector x, where this would
be an m by n matrix.
And we know that we can always construct this matrix, that
any linear transformation can be represented by
a matrix this way.
And we can represent it by taking our identity matrix,
you've seen that before, with n rows and n columns, so it
literally just looks like this.
So it's a 1, and then it has n minus 1, 0's all the way down.
Then it's a 0, 1, and everything else is
0's all the way down.
And so essentially you just have 1's down as diagonal.
It's an n by n matrix.
All of these are 0's, just like that.
You take your identity matrix and you perform the
transformation on each of its columns.
We call each of these columns the standard basis Rn.
So this is column e1, this is column e2,
and it has n columns.
en.
And each of these columns are of course members of Rn
because this is n rows and n columns matrix.
And we know that A, our matrix A, can be represented as the
transformation being operated on each of these columns.
So the transformation on e1, and the transformation on e2,
so forth and so on, all the way to the
transformation to en.
And this is a really useful thing to know because it's
very easy to operate any transformation on each of
these basis vectors that only have a 1 in its corresponding
dimension, or with respect to the corresponding variable,
and everything else is 0.
So all of this is review.
Let's actually use this information to construct some
interesting transformations.
So let's start with some set in our Rn.
And actually everything I'm going to do is going to be in
R2, but you can extend a lot of this into just general
dimensions.
But we're dealing with R2 right here.
Obviously, it's only 2 dimensions right here.
Let's say we have a triangle formed by the points, let's
say the first point is right here.
Let's say it's the point 3, 2.
And then you have the point, let's say that your next point
in your triangle, is the point, let's just make it the
point minus 3, 2.
I shouldn't have written that as a fraction.
I don't know why I did that.
3, 2.
Then you have the point minus 3, 2.
And that's this point right here.
Minus 3, 2.
And then let's say, just for fun, let's say you have the
point, or the vector-- the position vector, right?
3, minus 2.
Which is right here.
Now each of these are position vectors, and I can draw them.
I could draw this 3, 2 as in the standard position by
drawing an arrow like that.
I could do the minus 3, 2 in its standard
position like that.
And 3, minus 2 I could draw like that.
But more than the actual position vectors, I'm more
concerned with the positions that they specify.
And we know that if we take the set of all of the
positions or all of the position vectors that specify
the triangle that is essentially formed by
connecting these dots.
The transformation of this set-- so we're going to apply
some transformation of that-- is essentially, you can take
the transformation of each of these endpoints and then you
connect the dots in the same order.
And we saw that several videos ago.
But let's actually design a transformation here.
So let's say we want to-- let's just write down and
words what we want to do with whatever we
start in our domain.
Let's say we want to reflect around the x-axis.
Reflect around-- well actually let's
reflect around the y-axis.
We essentially want to flip it over.
We want to flip it over that way.
So I'm kind of envisioning something that'll look
something like that when we flip it over.
So we're going to reflect it around the y-axis.
And let's say we want to stretch in y direction by 2.
In y direction times 2.
So what I envision, we're going to flip
it over like this.
What I just drew here.
And then we want to stretch it, so we're going
to first flip it.
That's kind of a step 1.
And then step 2 is we're going to stretch it.
So instead of looking like this, it'll be twice as tall,
so it'll look like this.
Without necessarily stretching the x.
So how can we do that?
So the first idea of reflecting
around the y axis, right?
So what we want is, this point, that was a minus 3 in
the x-coordinate right there, we want this point to have its
same y-coordinate.
We want it to still have a 2 there.
And I'm calling the second coordinate here our
y-coordinate.
I could call that our x2 coordinate, but we're used to
dealing with the y coordinate when we graph things.
So I'll just keep calling it the y-coordinate.
But we want is this negative 3 to turn to a positive 3.
Because we want this point to end up over here.
And we want this positive 3 here to end up becoming a
negative 3 over here.
And we want this positive 3 for the x-coordinate to end up
as a negative 3 over there.
So you can imagine all we're doing is we're
flipping the sign.
This reflection around y, this is just equivalent to flipping
the sign, flipping the sign of the x-coordinate.
So this statement right here is equivalent to minus 1 times
the x-coordinate.
So let's call that times x1.
Because this is x1.
And then stretching in the y direction.
So what does that mean?
That means that whatever height we have here-- so this
next step here is whatever height we have here-- I want
it to be 2 times as much.
So right here this coordinate is 3, 2.
If I didn't do this first step first, I'd want
to make it 3, 4.
I want to make it 2 times the y-coordinate.
So the next thing I want to do is I want to 2 times-- well I
can either call it, let me just call it the y-coordinate.
It's a little bit different convention that I've been
using, but I'm just calling these vectors-- instead of
calling them x1, and x2, I'm saying that my vectors in R2--
the first term I'm calling the x term, or the x entry, and
the second term I'm calling the y entry.
But it's the same idea that we've been doing before.
I'm just switching to this notation because we're used to
thinking of this as the y-axis access as opposed to the x1
and x2 axis.
So how do we construct this transformation?
I mean, I can write it down in kind of transformation words.
I could say-- I could define my transformation as T
of some vector x.
Let me write it this way.
T of some vector x, y is going to be equal to-- I want to
take minus 1 times the x, so I'm going to minus the x.
And I'm going to multiply 2 times the y.
So that's how I could just write it in transformation
language, and that's pretty straight forward.
But how would I actually construct a matrix for this?
So what you do is, you just take your--
we're dealing in R2.
So you start off with the identity matrix in R2, which
is just 1, 0, 0, 1.
And you apply this transformation to each of the
columns of this identity matrix.
So if you apply the transformation to this first
column, what do you get?
So what we're going to do is to create a new matrix, A.
And say that is equal to the transformation of-- let me
write it like this-- Transformation of 1, 0.
That is going to be our new column, we're just going to
transform this column.
And the second column is going to be the transformation of
that column.
So it's a transformation of 0, 1.
Just like that.
And so what are these equal to?
The transformation of 1, 0.
So let me write it down here in green.
So A is equal to?
What's the transformation of 1, 0 where x is 1?
Where we just take the minus of the x term, so
we get minus 1.
And then 2 times the y term.
So 2 times 0 is just 0.
Now do the second term.
The minus of the 0 term is just minus 0.
So that just stays 0.
Then you multiply 2 times the y term.
So 2 times y is going to be equal to 2 times 1, so it's
equal to 2.
So now we can describe this transformation-- so now we
could say the transformation of some vector, x, y.
We can describe it as a matrix-vector product.
It is equal to minus 1, 0, 0, 2, times our vector.
Times x, y.
And let's apply it to verify that it works.
To verify that our matrix works.
So this first point, and I'll try to do it color coded,
let's do this first point right here.
This is minus 3, 2.
So that's minus 3, 2.
So what is minus 3, 2-- I'll do it right over here.
I could just look at that.
So what minus 1, 0, 0, 2, times minus 3, 2?
Well this is just a straight up matrix-vector product.
Minus 1 times minus 3 is positive 3 plus 0 times 2.
So plus 0.
So this is 3.
And then 0 times minus 3 is 0.
Plus 2 times 2.
This is 3, 4.
So that point right there will now become the point 3, 4.
It now becomes that point right there.
Let's look at this point right here, the point 3, 2.
So let's take our transformation matrix, minus
1, 0, 0, 2, times 3, 2.
This is equal to minus 1 times 3 is minus 3 plus 0 times 2.
So it's just minus 3.
And you have 0 times 3, which is 0.
Plus 2 times 2, which is 4.
0 plus-- so you got that point.
So this point, by our transformation, T, becomes
minus 3, 4.
So minus 3, 4.
And I kind of switch in my terminology.
I said, becomes, or you could say it's mapped to if you want
to use the language that I used when I introduced the
ideas of functions and transformation.
This point is mapped to this point in R2.
And then finally let's look at this point right here, apply
our transformation matrix that we've engineered.
Let's multiply minus 1, 0, 0, 2, times this point right
here, which is 3, minus 2.
Which is equal to minus 1 times 3 is minus 3.
And then 0 times minus 2 is just 0.
So this just becomes minus 3.
And then 0 times 3 is 0.
2 times minus 2 is minus 4.
So minus 3, minus 4.
So this point right here becomes minus 3, minus 4.
Becomes that point right there.
And we know that the set in R2 that connects these dots, by
the same transformation, will be mapped to the set in R3
that connects these dots.
We've seen that already.
I think that was 3 videos ago.
So the image of this set that I've drawn here, this triangle
is just a set of points specified by a set of vectors.
The image of that set of position vectors specifies
these points right here.
Specifies the points that I'm drawing right here.
Let me see if I'm doing it right.
There you go, just like that.
And low and behold, it has done what we wanted to do.
We flipped it over, so that we got this side onto the other
side, like that.
And then we stretched it.
And we stretched it in the y direction.
And we we see that it has stretched by a factor of 2.
We flipped it first, and then we stretched it
by factor of 2.
And, in general, any of these operations can be performed--
I mean, you can always go back to the basics.
You can always say, look I can write my transformation in
this type of form, then I can just apply
that to my basis vectors.
Or the columns in my identity matrix.
But a general theme is any of these transformations that
literally just scale in either the x or y direction, and when
I-- or, well, you could say, scale.
They can either shrink or expand
in the x or y direction.
Or flip in the x or y direction, creating a
reflection.
These are going to be diagonal matrices.
Diagonal matrices.
And why are they diagonal matrices?
Because they only have non-zero
terms along their diagonals.
This is the 2 by 2 case.
If I did a 3 by 3, it would be 0's everywhere, except along
the diagonal.
And it makes a lot of sense because this first term is
essentially what you're doing to the x1 term.
The second term is what you're doing to the x2 term.
Or the y term in our example.
If I had multiple terms, if this was a 3 by 3, that would
be what I would do to the third dimension.
Then the next term would be what I would
do the fourth dimension.
So you could expand this idea to an arbitrary Rn.
Anyway, the whole point of this video is to introduce you
to this idea of creating custom transformations.
And I think you're already starting to realize that this
could be very useful if you want to do-- especially in
computer programming-- if you're going to do some
graphics or create some type of multi-dimensional games.