 So in this lecture we've been learning about functions that are mapping between vector spaces and of those, the ones we care about the most are linear transformations. So imagine we have a linear transformation. It's a map T from X to Y where X and Y are vector spaces. We say that a map is onto, the more formal term is surjective but in the United States it's common and these are commonly referred to as onto maps. We say that a function is onto if for each vector in the co-domain there's at least one vector in the domain such that T of X equals B. That is, in other words, we could say that the co-domain and the range, the so-called image of the function are one and the same thing. We actually saw in our previous example that this can happen, right? We had a function and we showed that the image of the function was actually all of R2 and this was a map, this was a map from R3 to R2, right? So that was an example of an onto function. It was surjective because everything was obtainable through this function, right? We see a function is onto exactly when it's equal to its co-domain. The two things are one and the same thing. Related to this is the idea of a one to one function. A one to one function are sometimes they're called injective functions. This means that given any vector in the co-domain, I should say, well, yeah, if you take any vector in the co-domain, there's at most one vector that maps to it. In other words, if there's ever an instance where T of X equals B, then if there's some instance like over here, so if T of U equals T of E, so if there's two vectors that have the same image, it must have been that they were the same vector to begin with. So let me explain the etymology of these terms a little bit. Oftentimes people, when they think of transformations, functions of some kinds, we think of our domains and co-domains as these blobs, right? So we have the domain over here, we have the co-domain over here. So the domain is the set of things we are mapping from. So you got these little vectors floating around over here and the co-domain is the set of vectors we are mapping to, right? And then the function itself will be some association with vectors, you know, we draw these little arrows to indicate, there's some associative vectors going on over here. So a function is onto if every element in the co-domain has someone mapping onto it, which in this picture right here, you would see that this function is not onto because there's a vector who doesn't have someone mapping onto it. And so onto means that every vector in the co-domain has an arrow mapping to it. So we might have, you know, something like this, oh, there's another vector maps over here. This would now be an example of an onto map. Every vector B in the co-domain has at least one vector which maps onto it, which is why we call it onto or a surjective function, right? One to one, what does one to one mean? A one to one function, I'm gonna add another guy a little over here, a one to one function means, if we look at the arrows, there's no instance of a vector which gets mapped onto twice or thrice or more than once, right? And so in this picture right here, this would be a violation. This is not a one to one map because there are two vectors mapping onto the same vector. We don't allow that for one to one. If this map was to be one to one, let's get rid of this, be very, very precise. This guy would have to go somewhere else. So maybe we're like, oh, this one's gonna map over here. It doesn't necessarily have to be an onto map, right? To be one to one, you don't have to be onto. What it just means is that every vector has at most one vector mapping onto it. That's one to one. That is every vector over here, it goes to one. So there's this one to one correspondence between the domain and the image of the transformation. Now, if you put these ideas together, what we'll stick here, if you put these ideas together, we say that a map is bijective, bijective meaning that it's two-jective, right? Like a bicycle has two wheels. It's both surjective and injective. We call this bijective map. This is also called an invertible map if it's one to one and onto. What's interesting about bijective transformations, the reason why we call them invertibles is because they have an inverse. Every transformation that's bijective, there exists another transformation. So if T is a transformation from X to Y, there'll exist another transformation, S, which is a map from Y to X and as the direction goes backwards. And when you compose S with T or T with S, you get the identity map. The identity map sends the vector X to X, like so. And so this is often referred to as the inverse map, S is T inverse, because the composition, they undo each other. And you see that a bijective would mean that everyone gets mapped onto and there's this one-to-one correspondence going on here. With a bijective map, every vector in the co-domain gets hit once and only once. To be one-to-one, it means that every vector gets hit at most once and to be surjected to be onto, you show that every vector's hit at least once. And so that when you put the two together and get bijective, that means every vector's hit exactly once. So let's take an example. You probably can guess which example we're gonna do here. We're gonna take our example we did previously, right? So we had the example that T of X was equal to X1 plus 2X2 and X3 minus 3X2, like so. And we said a little bit about this. We have shown that with this transformation, it was onto, right? The image of this transformation was all of R2. By solving this system of equations, we saw previously that you could just take X1, X2, X3 to be the vector B1, 0, B2. And that would then give you the vector you're trying to do. So to show that something is onto, to show that something is onto, to show onto-ness, to show onto-ness of T, what you're gonna do is you are going to then show that the system of equations T of X equals B is consistent, it's consistent for some general vector B that's in the co-domain, like we saw previously. So this map was onto. Is it one to one? And the answer to that's gonna be no. There's a very nice and slick way of checking whether a function is one to one or not. And I forgot to mention this, that's because it was hidden here. Someone forgot to tell everyone. A proposition here, a linear transformation T from X to Y is going to be one to one, if and only if the kernel is just the zero vector. Every linear transformation will map the zero vector to the zero vector, but a one to one map means that the only thing that maps to zero is the zero vector itself. Now, one direction is obvious. If your map is one to one, no two vectors can go to the same spot. Since the zero vector is already mapping to the zero vector, the one to one condition would forbid anyone else from going there. But it turns out, and we'll talk about this another time, that if the only vector mapping to zero is itself zero, then every other vector will also be unique in its image. So it's gonna be one to one. So this is a very nice condition to check and clearly a map will be onto if and only if its image is equal to the domain. So coming back to this example, we did see previously, by computing the kernel, we showed that the kernel, the kernel of this transformation was equal to the set of vectors of the form T times negative two, one, three, where T is an arbitrary real number. This is much bigger than just the zero vector, right? So the vector negative two, one, three itself was in there. And so this means that this is not just the zero vector, right? And so this would tell us that it is not one to one. So we've already shown that this function was not one to one because the kernel was too big. We showed that it was onto because the image was everything. So this is not an example of a bijective, but it is a surjective map. I wanna do one other example before we end this section of the book here. So consider the map T, which is a map from Z two, three to Z two, four. All right, Z two, three to Z two, four. So what this means is we're gonna take vectors, binary vectors. So our entries are either zero or one, Z two, and there's three of them. So we have a sequence of three binary numbers, or we call those bits, right, in like computer lingo. And then Z two, four, this would be four bits of information. And it has the following rule. X one, X two, X three, it maps to X one, X two, X three. And then the fourth bit is X one plus X two plus X three. So first of all, this is a linear transformation. By the rule we mentioned earlier, you can notice that each of the components is a linear combination of the input variables. We can also show it directly by showing it preserves addition and preserves scalar multiplication. Can we show that this thing is one to one or onto? Well, we'll start off with the kernel. The kernel of this map is, well, we'll see, we'll see, right? This transformation, it sends X one, X two, X three. It sends this to the vector X one, X two, X three, and X one plus X two plus X three. Like so. And so we have to then notice what's happening here. We have the system of equations now where, I'm sorry, the vectors won't equal, T of X one, X two, X three equals these things. And this is supposed to equal the zero vector in Z two four. So this gives us a linear equation of the following form, X one equals zero, X two equals zero, X three equals zero, and X one plus X two plus X three equals zero. Ignoring the third equation for a moment, notice the first three equations tell us that each entry has to be zero. And so the only solution to this would be if X one, X two, and X three are all equal to zero. That's the only thing that maps to zero according to this map. Therefore the kernel of this transformation is none other than the zero vector in Z two four. So this then tells us emphatically that our function is one to one. This is a one to one transformation. Is it onto? Is it an onto map? Well, to show onto, right, we're trying to compute the image of T. What is that equal to? Well, we have to then take this equation T of X, and we have to set this equal to an arbitrary vector and see what we get there. And so the corresponding system of equations would look like the following. You're gonna get that X one equals B one. You're gonna get X two equals B two. You're gonna get X three equals B three. And you're gonna get X four. Well, sorry, there's no X four. X one plus X two plus X three equals B four, like so. Now by substitution, we could substitute these expressions into the fourth equation very quickly. We see that this system tells us that B one plus B two plus B three equals B four. That would have to be true if we're consistent. And we could actually come up with some vectors where that's not true. Like for example, take the vector zero, zero, zero one for B. You'll see that this is not a solution, right? Because if you take zero plus zero plus zero, that's equal to zero, which is not equal to one. And so the answer to this is no, this function is not, this is not onto because we found a vector, which is not in the image here. It's not in the image. In fact, if we wanna be specific about the image, the image is going to be the set of vectors of the following form. You take vectors of the form, B one, B two, B three, B one plus B two, B three, where then B one, B two, and B three are gonna be arbitrary bits. And so in fact, those are the only vectors that are gonna be in the image, right? It has to be. We only can accept vectors where the fourth entry is the sum of the first three. So yeah, it's not onto, but it is one to one map. So I wanna mention that with this example, this is actually a very important example because this right here is one of the first examples of an error detecting code. So in computers, right? If you have a digital computer, they have different parts of the computers have to communicate to each other, B, B, B, B, right? And so like the first, maybe you have to send like a three-bit message of zero, one, zero, that's computer talk, right? And so you have to transmit this to some other part of the computer. Well, computers as much as we love them, they're not perfect, they're machines, they are prone to error. Like as you're transmitting this message, there is sort of the proverbial noise in the background. As humans, we have this problem all the time when we talk to each other, right? It's like, what did you just say? Even though we were talking face to face, maybe, you didn't hear everything that was said because of maybe some other type of noise in the background. Computers have issues like this as well. And what could happen is that when you send the message zero, one, zero from one part of the computer to another, the receiving part might have heard zero, one, one, which then the computer will follow the instructions associated to the code zero, one, one, but that can have a dramatically different effect on the process that's going on and therefore it could cause error in your calculation. That would be really horrible. So what computer scientists have done is things like the following. We aren't gonna send the message zero, one, zero. Although we love that message, we're gonna send the message zero, one, zero, one. Even though all we really care about is the first three bits, we're gonna send an extra bit for the following reason. If we were to send this message, and remember the third bit came in erroneously, our receiver knows that this message has an extra bit. And what we can do is the following. We're gonna take the first three bits zero, one, zero and add them together, zero, one, zero. This adds up in binary, this adds up to one, right? On the other hand, so the receiving, the descender, we took zero plus one plus zero, that gives us one. This value we put in as an extra bit, this is sometimes called the check bit. The first three are information bits. The last one is this checking bit, just to make sure the message is sent correctly. Because if the message was sent and received erroneously, the receiver then could check. The three information bits come first. If you take zero plus one plus one in mod two, this should be equal to zero. And then you look at the check bit, it's like that's not zero. There's an error right there. And so the receiver is able then to detect that the message was sent erroneously and therefore it won't follow the command zero, one, zero. It knows there's a mistake, but we don't know where the mistake was. So therefore the receiver can ask the sender to please send again, resubmit, because it detected this error, which is a much better thing than the computer doing something incorrectly. It takes the time to ask again. And this comes from basically the linear transformation you see in front of us. We have this information, these information bits, X1, X2, X3, but we don't send that, we send the image of this linear transformation. This is what we send to the receiver, giving the receiver the power to detect an error if there was an error in transmission. It turns out with a little bit more linear transformation, we could actually correct this even better to make what's called an error correcting code that the receiver can detect there was an error and without asking for resubmission, we can correct the message, to get the original message that the sender sent. It's pretty impressive and it's dependent upon some very basic linear algebra of linear transformation. So I wanna present that example to you on why we care about linear transformations, why do we care about them being one to one or onto? There are many applications in the sciences. This is an example from information science. And that then finishes section 1.4 about linear transformations. We'll see some more about these in the future of course, but this gives us enough of an introduction to get started right now.