 Let the set Z2 to the m-by-n power denote the set of all m-by-n matrices whose entries come from Z2. Now, something to remember here, when you have a matrix m-by-n, the first number always counts the number of rows in the matrix, and the second number then counts the number of columns. So an m-by-n matrix will have m-mini rows and n-mini columns. It's reverse alphabetical order here. And then the other thing I should mention is that this notation right here is not super standard. There's, you know, like I think in Judson, they use the notation m-sub m-by-n and then Z2, something like that. Again, it's like the matrices, which are m-by-n whose scalars come from Z2, something like that. It doesn't make much of a difference here, but this is the notation I used in my linear algebra course, and so that's what we're just going to use right here as well. So Z2, m-to-the-n, this in particular is a Abelian group, right? With respect to matrix addition, addition would be associative, commutative. The zero matrix acts as the additive identity, and we'll just denote that as a zero, the zero matrix. Every matrix has an inverse, like if you have a matrix A, its inverse would just be negative one times the matrix, right? Which, when you're working by, that's sort of like the argument in general, of course, but if you're working binary, there is no such thing as a negative, every element is its own inverse, right? A plus the A is equal to the zero matrix, you're going to see that. So Z2 to the m-by-n, this is an Abelian group, right, with respect to addition. And this is true not just for matrices, if you take column vectors, we're going to have that as well. In fact, though, we can do, it's also a vector space that we should describe here, because in addition to being close under addition, it's close under skill and multiplication, which is another type of operation, it's not, a scalar multiplication is not technically a binary operation, how we've usually defined it, because scalar multiplication, you take two arguments, two operands, you're going to take your field, right? And then you have your vector space, and when you multiply a vector by a scalar, you give back a vector again. And so binary operation would require the two operands are the same and you return something like that. So it's a little bit different, but the same idea, we can still call it an operation for, you know, the lack of a better term right here. And so this group right here, this Abelian group also has equipped on it, scaling multiplication, which makes it into a vector space. Now, admittedly, when you have the binary vector space right here, the only scalars present are zero and one, I mean, that's your field in consideration right here. And so scaling by one will just give you back the original vector and scaling by zero gives you the zero vector always. And so really the, you know, the extra, the extra scaling multiplication is not going to do much for us. But I mean, this is a, this, this, this group is also a vector space. And that extra perspective does inform us why we make some of the decisions we're going to make based upon the linear algorithm play. So imagine we have a matrix H, which is going to be M by N. Recall that from linear algebra, the null space of H, which we're going to denote null of H, this is the set of all vectors. So let me write this out here, the null space of a matrix A, this is going to be the set of all vectors X, which live inside of our vector space, in this case, is Z2 to the N, such that HX is equal to the zero vector, right? So this, oh, you can see it right here. I didn't even notice it was on the screen. The null space of H is equal to all of those vectors that when multiplied by H give you zero. And this will then be a subspace of Z2N right here, where N was the number of columns of the matrix H right there. And so yes, this null space itself is a subgroup of this group right here. But like I said, that we can also view this as a vector space and therefore this is a so-called subspace. I mean, it's a subspace, it's a vector space inside of a larger vector space. But like I said, the scalar multiplication really isn't doing much for binary arithmetic. So essentially, the null space for our purposes as, you know, students of abstract algebra, this is going to be a subgroup of this abelian group right here, okay? And so then this leads to the main idea for this chapter, chapter eight, that if you have an N by N matrix, we can construct a code using the null space of A. So basically, if we take any subgroup of Z2N, we can make a group code out of that, right? It's a code, which is also a subgroup. But if we construct the group code using the null space of a matrix, we call that a linear code, okay? Let's take an example of such a thing. Let's take the binary matrix H equals this 3 by 5 matrix you see right here. And oftentimes, we're going to describe matrices by their rows or columns. So like this right here, these would be the column vectors of the matrix. So it has five column vectors. And so these column vectors belong to Z2, 3. So you got 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, and 0, 0, 1 as the vectors in play right there. So let's consider for a moment, how do we compute the null space of this? Because there's going to be two very important, two fundamental spaces of the matrix that are going to be in play here. The first one I want to remind us about is the column space. This one's not going to be super critical, but I do want to mention here. The column space here is going to be the span of the column vectors of this matrix. So you get the span, you're going to get the span of 0, 1, 0, 1, 1, 0, 0, 1, 1, who's my next 1, 1, 1, 1, and then 0, 0, 1, which I don't anticipate that's going to be a basis for this. Recall that the span, this is the set of all linear combinations of these five vectors, which a linear combination would look like any possible sum of any combination of sums and scalars of these things. And so that would give us the column space. Like I said, that's not going to be in play a little bit later in our series here. For the null space, though, how does one compute the null space? How do you decide if a vector is inside the null space? Well, basically, you just think of the numbers in this matrix as coefficients of a linear system. And so we end up going out trying to solve the homogeneous system of equations, homogeneous meaning that the right-hand side is all the same and they're all zeros. So how you want to interpret this is the following. We'll look at the first row. And so you think of these as the scalars, the coefficients in a linear equation. So you have 0 times x1, 1 times x2, 0 times x3, you have then 1 times x4, then 0 times x5, and this is supposed to equal to 0 on the right-hand side. That's how we want to read this. And that's where we get this equation right here, x2 plus x4 equals 0. The second row, then, would it be read as x1 plus x2 plus x3 plus x4 is equal to 0? And then the last one right here, you're going to get 00111. That we would read as x3 plus x4 plus x5 equals 0. So finding the null space comes down to solving this homogeneous system of equations. Now you can solve it from a variety of techniques like substitution, elimination. Those work very well on a binary sequence. Like elimination is really nice because the only coefficients are 0 and 1, so it's very easy to eliminate things. But you can also solve this by the usual row reduction techniques like Gaussian elimination, Gaussian elimination. And I actually would treat this as a matrix, right? So if I wanted to row reduce this thing, what I would do is I would consider, okay, I want a 1 in my first pivot position. So I'm going to swap the first two rows, like just interchange their order. And so we end up with 11110. We're going to get 01010 and then 00111. So I just swapped the rows, the order of the first two rows. So I get a 1 in my pivot position because you want a 1 in this box. You want to make this downward staircase of 1s here. So the next pivot would be right here, all right, which there's already a 0 below it. So that's great. So then my next pivot, I'd go right here. So this matrix is now in what we call echelon form, where I get this downward staircase of the 1s and everything below is 0. That's what we want for echelon form. It's even better if we can get this into row reduced echelon form. And so to do that, we want to now start getting moving, now moving right to left. We want to get zeros above the pivot position. So how do we get rid of those there, right? Well, we want to get rid of this 1. How can we go about doing that? Well, we could row reduce as we could take row 1 and add to it row 3, something like that. Notice that if you do that, since you just have zeros here, you'd add zeros. So you get a 00. I don't actually bother writing the zeros when you're just adding the zero. So you're going to get a 111. And again, working with binary arithmetic here, you're going to get 110010101. I didn't do anything to the second row, nor do I do anything to the third row, like so. And then so then focusing the next on my next pivot 2, we don't want a 1 right here. We want to get rid of it. So we can do that by replacing row 1 with row 1 plus row 2, for which we get a plus 1 right here. We get a plus 1 right here. And so what would that look like here? Well, the first column, nothing happened there. With the second column, you're going to get 010. For the third column, nothing happened there either. And if you just pause here for a second, you'll notice that this right here is just the identity matrix. We kind of like that when this shows up inside of our matrix, when we're trying to row reduce it. For the last two columns, you're going to give 101. And then you're going to get 101 and then 101 right there. And so this matrix right here is the row reduced echelon form, sometimes called RREF, for this matrix. And then from that, we want to turn that back into a system of linear equations, which you can see illustrated right here. So you're going to see those pivots along this diagonal right here. Same thing going on there. Looking at the first row, you get x1 plus 4x4 plus x5 equals 0. The second row, you got x2 plus x4 equals 0. For the third row, you get x3 plus x4 plus x5 equals 0. And so from this, we can actually find the null space of the matrix, for which if we think of a generic vector in the null space x, it's a vector with five entries, the number of columns, x1, x2, x3, x4, x5. Now for each of these equations right here, we could solve for the pivot position. So we could solve for x1. This will look like x1 equals x4 plus x5. You can move x4 and x5 to the other side. Normally you would be subtracting them, but as we're working mod 2, a subtraction and addition are actually the same thing. And so notice that this first equation gives us this dependent variable condition that if you kind of choose x4 and x5 freely, then x1 will depend upon that choice. And so x1 is equal to x4 plus x5. If we do the same thing for the second equation, you can move x4 to the other side and you're going to get x2 equals x4. So we can actually replace x2 with x4. And then lastly, if we take the third equation we solve for x3 or pivot position, we're going to get that x3 equals likewise x4 plus x5 in particular is equal to x1. And so we make that substitution right here. Now x4 and x5, there was no pivot positions in those columns. We're not treating them as dependent upon anything. They're free variables. So x4 and x5 will just leave them alone. And so then what we can do is we can decompose this vector with respect to the x4s and the x5s. So if you look at which positions have an x4 and at the first, second, third, and fourth positions. So x4 times the vector 1, 1, 1, 0. Did I say enough ones there? 1, 1, 1, 1, 0. That gives you there. And if you look at the x5s, you're going to get in the first position, the third position, and the fifth position. You get so right here. And so this right here, these two vectors give us a basis for the null space of our matrix H right here. And so therefore our code, our linear code C will be the span of these vectors, writing them now horizontally, 1, 1, 1, 1, 0. And then 1, 0, 1, 0, 1. And this is a basis. And so this code is going to be two dimensional. This code can be used to encode two bits of information, although there's going to be five bits in the codes themselves, right? And if you want to see what the code is, the code is going to be all the possible linear combinations of these things. Let's call the first vector u, the second vector v right here. So what are the possible combinations? Take 0 times u plus 0 times v, that gives you the 0 vector. OK? You could get 1 times u plus 0 times v. That would just give you back u, what you see right here. You could take 0 times u plus 1 times v. That would just give you back v. And then the last possibility, you could take 1 times u plus 1 times v. So just u plus v. And when you add those together, mod 2, the first digit, the first bit would be 0, then a 1, then a 0, then a 1, and then a 1, what you see right here. So the null space of this matrix then gives us a 5, 2 block code. And looking at the words here, this is a block, this would be a group code, right? So we have a minimum, we have a weight of 4, 3, and 3. So the minimum weight is 3. So that's the minimum distance of this group code. So that means this code should be able to detect up to 2 errors and can correct automatically up to 1.