Main content

## Linear transformation examples

# Linear transformation examples: Scaling and reflections

## Video transcript

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.