 So, we have been looking at majority logic decoding, I was describing the general principle to you in terms of finding estimates for each bit of the code work and I was giving you an argument for how if you have j orthogonal parity checks, parity checks orthogonal on a particular bit then you can hope to correct j by 2 errors for each bit. So, I am going to make that a little bit more precise this time and give you some exact things as to what happens when j is odd, j is even, etc. The best way to think about that is through an example. So, we are going to see an example and we will see some points there and then I will generalize that as the decision. Yes, I think that is the best way of doing it, it is not, I am not sure if I can see that you are able to do it first, I am going to see that now. So, we are going to start with a very simple example of 734 code. And how am I going to construct the 734 code? Yes, so it is going to be a cyclic code. Okay, so let me see how much you remember about cyclic codes. If I have a 734 cyclic code, what is the number of this code? So, 734 cyclic code, what can be its generator problem? So, what is the starting point? BDB 4. BDB 4, okay. So, it should also be? It is irreducible. GFX is not irreducible. How do you find GFX? What are the other properties? It has to divide something. It has to be, is it as? It is per 8. It is per 7. Okay, so it is going to be, it is per 7 plus 1. So, you have a factor, it is per 7 plus 1. So, how does it is per 7 plus 1 factor? It is plus 1 and all those people, all the other two factors. It is per 3 plus it is plus 1 and then plus it is per plus 1, okay? So, you have to take GFX to be one of these things. So, let me say I take GFX to be one of these things, let me think about it one second and then we will pick it. It is really a matter, I think, but I want to make sure I have the right thing for it. Okay, so we will pick it as 1 plus X times 1 plus X plus X times. That is it. That is it. So, this is the generator matrix, okay? So, so if you want to do, if this is generator polynomial, let us simplify this. It is going to be 1 plus X plus X times 3 plus X plus X times 1 plus X times 4, so you get 1 plus X times plus X times 2 plus X times 4. Okay, so if you make a generator matrix out of this, I will never look. 1 0, 1 1, 0 0, 1 0, 1 1, 0, 0 0, 1 0. That will be the generator matrix, right? And what about the parity check matrix? How do you think for the parity check matrix? There are four rows and seven columns. How do I get a construction for the parity check matrix, right? How did I do that? You have to find some other polynomial. Just like you find the generator polynomial here, you have to find the generator polynomial for the dual, right? You know the dual is also a cyclic code. How do you find the generator polynomial for the dual? So, you have to divide X bar 7 plus 1 by g of X. You will get some polynomial. That is the check polynomial and then you have to do something to the check polynomial. What do you have to do? You have to do a reverse, right? Then you will get the generator polynomial for the dual. So, what is the check polynomial here? X bar 3 plus X bar plus 1. So, you do a reverse, what will you get? 1 plus X plus X bar 3, okay? So, the flip that you do, you get 1 plus X plus X bar 3. So, 1 plus X plus X bar 3 is the generator polynomial for the dual. So, with that, let me do the parity check matrix, okay? So, the first row is 1 plus X plus X bar 3. And the next row is 0 1 1 0 1 0 0. The next row is 0 0 1 1 0 1 0 0. The final row is 0 0 0 0 0, okay? Okay, so now I am going to start looking for parity checks, which are optional on the first bit. Let's say you start with that, okay? So, for that, a good starting point is to list all the code words of the dual, which have a 1 in the first position, right? That makes the most sense, because you know my optional parity checks, always have power 1 in the first position. Let me list out all the code words of the dual, which have a 1 in the first position. How many such code words will be there in the dual? Sorry, half of the total, right? So, 16 are there, half of them will have 1, so 8 of them will be there. So, let's try to list all the 8 of them, okay? So, it's a bit of a, it's a bit difficult without looking at the matrix. So, let me say I copy the matrix here, okay? So, another thing I can do, which is something I have not done in the past, is to just basically come down like this, okay? So, I have a parity check matrix there. So, let me, let me list out the code words, okay? So, what are the candidate code words, all right there? So, the first one is clearly 1101, 0, 0, 0, 0. How do you find the other code words, which are, which have a 1 in the first position? Yeah, I will take the linear combinations, we have to keep the first row all the time, right? So, you can't get rid of the first row, and then you can make arbitrary combinations, which are the mining, okay? So, you can get 8 different ones. The first one actually corresponds to 0, 0, 0 here. And then you keep putting more and more, okay? So, let's see, I'm going to write down as many as I can. Let's see, 1011, 0, 0, 0. 1110, 0, 0, 0. Then I'll do the last one, it should be 1100, 0, 0, 1. Then let's do the first three, it's going to be 1, 0, 0, 0, 1, 0. I'll do the first, the third and the fourth. It's going to be 10, first, third and the fourth, right? So, first, third and fourth. So, it's going to be 1111, first, third and fourth, 111. Okay? Then we'll do the first, second and fourth. Okay, so it's going to be 1, 1, first, second and fourth. It's going to be 1, 0, 1, first, second and fourth, 0, 0, 1, 0. Okay, and then the last one is everything together. It's going to be 1, 1, 0, 0, 1, 0, 1, 0. Okay, so those are the candidate parity checks. Okay, so from here I won't identify parity checks which are orthogonal, right? All of them would qualify in the first criteria that the first bit is 1. But then I also want the other bits to never overlap. So, suppose I take the first one, what else will be a first, fifth and seventh, I go and put candidates, second, third, fourth, fifth and then, seventh. So, these three guys satisfy the property that I want. They are orthogonal on the first flip. So, what are these parity checks? The first parity check says C 0 plus C 1 plus C 3 plus 0. This one says C 0 plus C 4 plus C 5 equals 0. This one says C 0 plus C 2 plus C 6 equals and this numbering is 0. So, it is a little bit different. So, you see C 0 is checked by all three of them and then 1 and 3 are involved in the first case, 4 and 5 are involved in the second guy, 2 and 6 are involved in the first case. So, they do not have anything in common. So, using these three checks, I can definitely correct one error. So, these are the parallel parity checks. So, suppose let us say the third check was not there. So, maybe with just two checks, then we do anything is what I am going to do next, but let us, so this is an incident. So, you find three, this is one of, so you remember this was a quick call. So, once I find parity checks are done on the first bit and done. What are the parity checks are done on the second bit? And we take this guy and then the next bit, next bit on, just keep shifting it, you will get all that. So, you can correct one error by another order of the decoding in the 734 code. So, I have pointed one minor thing here about how many parity checks you need to correct one error. So, let me write it down a little bit more clearly. So, how will my decoder work? So, let me write that down also. So, I am going to try and evaluate three checks. Suppose I am given a receipt value r0, r1, r2, r3, r4, r5, r6. What will I do? First check and evaluate this. So, it is called s1. It will be r0 plus. No, no, no. It is not worth that. So, it turns out you can do it in two ways. So, the way I described it, I would get c0, cap1 to be equal to what? r1 plus r3 and then I will have a c0, cap2 which would be equal to r4 plus r5. I mean finally, I would have a c0, cap3 which would be equal to r2 plus r6. And then what will I set c0, cap to be? Majority of c0, cap1, c0, cap2, c0, cap3. So, that is like correctly estimating the bits of codeword from the orthogonal parity checks that I have. So, you can also think of this as an evaluation of the error polynomial. So, instead of finding the codeword polynomial one bit at a time, you can find the error vector. So, instead of finding the codeword vector one bit at a time, I can also find the error vector one bit at a time using a very similar idea. So, notice instead of evaluating c0 like this, I can also say the error. So, what can I say? So, this is here. So, just finding the first bit of the codeword of here. Suppose I want to find the bits of the error vector, how would I do that? So, what should I do? So, for that, you would have an error vector e which is again equal to e1 plus e2, e3, e4, e6. And then you have a c0 plus c0. This is given to you. So, evaluate syndromes. So, the first syndrom I evaluate is going to be s1 which is r0 plus r1 plus r3. So, that can look at what I had here. The first syndrom is r0 plus r1 plus r3. The second syndrom is r0 plus what? What will be the second syndrom? r4 plus r5. So, let's say I stop with this. So, I will show you what happens when I stop with this. So, what do I know about r0? It is e0 plus c0. So, I can put that in and then I would know c0 plus c1 plus c3 is 0. So, definitely s1 is also equal to e0 plus e1 plus e3. And s2 is e0 plus e4 plus e5. Is that okay? That much? All right. So, now, it turns out I can do the following about e0. So, from s1 and s2, I can set e0 cap to be majority of s1, s2. Suppose I do that. Suppose I set e0 cap to be majority of s1, s2. Pi implies 0. So, what does it mean by pi? If s1 is equal to s2, I will simply say 0. So, this is the rule I am going to use. Notice this is very different from the rule here. So, it is a little different. But you will see this rule is also good enough to correct one error. So, let's look at that. So, here I am using all the three after the parity checks and the highly correcting one error, the majority, and that will be perfectly clear. There is no problem there. Here, I am using only two of these things. And hopefully, they should work out on both sides. So, I am going to set e0 cap to be equal to the majority of s1 and s2. And in case there is a pi, so if s1 is 0 and s2 is 1, there is no clear majority. I am going to say e0 is 0. e0 cap is 0. So, let me drop that down very clearly. Pi means e0 cap is set to 0. So, we break the tie and solve around 0. That is what we do. So, let's look at this case and try and see if it can correct one error. So, can you think about it? Can you tell me if it is going to correct one error or not? What is the meaning of correcting one error? There is one error I should determine e0 at parity. Will that happen? Why will that happen? So, that is the thing. So, you should see if the error after the d0 or not. Suppose the error occurred at d0, that is the only error. Other things will not be in error. What will be s1 and s2? Both will be 1 and so you will decide e0 cap is 1. Suppose there are no errors in any of these things, both s1 and s2 will be 0. So, you will get e0 cap to be 0 again. Suppose e0 is not in error, e0 alone is not in error. Only one less error of these things can be in error. So, one less s1 will be 1, s1 will be 1, s2 will be 0 or s1 will be 0, s2 is 1. Then what am I doing when I have a type? I break it into a bit of 0 which means e0 has this accurately determined. So, if you think about it in terms of the error vector determining the error vector, if you have j orthogonal parity checks and j is even and you use the same logic for finding e0, the error vector. Even if j is even and you have j orthogonal parity checks, j by 2 errors can be found. As long as you break the tie in favor of c0. So, in the c0 hat it may not be very clear why is it that there being even is good enough. But when you think in terms of the error vector it is not very clear. So, it has to work out right. So, that will be a result which we will keep in mind. So, we will say, if we have j orthogonal parity checks, then j by 2 errors. So, even our error, it does not matter, j by 2 errors. So, whenever it is even error, it is going to work out. Just have to remember that in the best way to think about this is in terms of the error vector not in terms of the cobalt vector. If you think in terms of the cobalt vector it will get confused a little bit. But you move on to the error vector and then you use this idea of how to break the tie in favor of c0 and whether that particular bit you are looking at might be an error or might not be an error. So, it is an error, then you have strictly less than j by 2 errors also. So, majority will be clearly one. So, it is not an error, then you might get a tie. But if you get a tie, you just break the tie in favor of c0, anyway it is not an error. So, that is the idea. So, if you think about it very carefully, it does not work out. So, you keep the error at present mind, this will be nice. So, I did not formally prove it, but it is clear. I mean, if you write down the argument, you will get the same. So, it is a simple proof by example. So, this is how you look for orthogonal parallel checks and do decoding. And clearly, I convinced you that the 734 cyclic code that we had here has a simple method to have a decoder which works for you next. So, what we are going to see next is a more slightly more complicated example. We will take the 743 Hamming code. So, let us take the 743 Hamming. Here we will see it is a little bit more complicated and I will tell you slightly more advanced method we will have with decoding. So, the previous method we will have with decoding is what is called one step method we will have with decoding. We are doing it in one step. You can also do multiple steps and it turns out the 743 Hamming code will need multiple steps. I am going to describe that with an example first. So, we will see the example step simple. We will come to it and then we will be able to generalize. So, the Hamming code I will take gfx to be 1 plus x plus x bar 3. So, yes. I mean, that is not guaranteed, right? So, if you have less than j by 2 errors, then definitely you find the code. If it corrects correctly, it will go back to the code. If you have greater than j by 2 errors, it can still work. I mean, there is nothing that stops you from doing this if you have greater than j by 2. But then you are not guaranteed anything. It may or may not be a code. Some other bits that can happen. In fact, it may even work for everything. It depends on how. So, it only has to work for the message bits, right? As long as it works for the message bits, you are happy. The bits can be an error. So, that is why I am saying it may even work correctly. See, when you are able to get the code right, it is necessary to get the message. How do you get the code right if you only get the message? You have to encode it again. How do you get the code right if you encode it again? It is necessary to get the message bits correctly. Not when there are j, j by 2, right? So, if it is j by 2, if e0 is an error, then they can do only strictly less than j by 2 errors outside of it. So, a majority of the checks will be 1. Here, a majority will be 1. There will be no time. There is no chance of a time. There is only j by 2 errors. If already e0 is an error, in the remaining days, you cannot have j by 2 errors. You will have strictly less than j by 2. So, you have j equations. So, there will be a clear majority which is 1. There is no problem there. In case e0 is not an error, then you can have a time. At worst, you will have a time, but the time you are taking is over 0. So, that is the idea. So, you just look at when you can have a time closely, you get the answer. You cannot have a time when e0 is an error. That is the important thing. e0 is not an error. You can have a time. So, of course, you can set a little privacy. So, we go back to this slide. This is the generator matrix. What is the parity check matrix for this? I wrote down just now. You can think of any different ways the parity check matrix will come out. This is where the parity check matrix are at code. That is what we have done. So, it is 1 0, 1 1, 0 0. So, the parity check matrix is going to be 1 0, 1 1 1, 0 0, 1 0, 1 1 1 1. Another way to think about it is it is alpha 0, alpha 1, alpha squared, so on. So, it is 1 plus 6 plus 6. If I pre-written this way, you get this. So, it is just the other that matters. You can think of it in so many ways, but it is the cyclic version of the Hamming code's parity check matrix. So, you get that. So, now suppose Hamming code, I have 16 different code words. Suppose I want to find, set of all, possibilities for where, for orthogonal parity checks in bit 1. How many possible candidates will I have? There are 8 code words in the dual. How many possible candidates do I have for orthogonal and bit 1? How many do I have? So, 4 is just, it is very, very unlikely. So, if we list it out, you will not get anything. So, what I am going to do is, I am going to list out all the 8 code words. So, from there I will try to see if anything is possible. So, let's list out all the 8 code words. The first code word is L0. L0 is not going to be a parity check, right? So, we do not consider L0. So, let's look at the other guys. So, 3 of them are already here. So, I want to repeat it and write the remaining 4. So, termination of first 2 is 111, 0010. First and third is 10, 01, 011. Second and third is 01, 11, 001. And all 3 is 11, 0010. Okay, those are my 7 candidates for parity checks for my code. All the possible code words in the dual, they are candidates for the parity checks. And if you look for, can you find 2 parity checks which are orthogonal and bit 1? Is it possible? It won't work. When any 2 parity checks you take that have 1 in the first position, they will at least overlap in another place. It seems like a slightly disastrous situation. The way you get over this is by doing what's called 2-step majority logic decoder. You won't try to find E0 in the first step. You find something else in the first step. What do we find in the first step? I will try to find E0 plus E2 in the first step. That's it. So you find parity checks orthogonal and not just E0, not just 1 on 0 and 2. Previously you were finding a parity checks orthogonal and 0 alone. So it has to be 1 and 0 and no other thing should overlap. Now I say my parity checks have to be 1 at 0 and 2nd position. 0 and 2nd position, they have to be 1. But then the other things should not repeat. Let's see if we can find 2 checks which satisfy this condition. First step is E0 plus E2 a good choice. Maybe it's not a good choice. Is this correct or did I make a mistake here? Did I make a mistake in the XS? No. It's okay? First and fourth we are right. It should look right. So first and fourth, so if you look at the first pair and the fourth pair, what happens here? What happens to these two checks? What are the first checks in the fourth check? First thing tells you C0 plus C2 plus C2 plus C4 is 0. What does this guy tell you? C0. What do you write? C0 plus C2. What do I write? C1 plus C5 equal to 0. So what happens here is these two checks both involve C0 and C2. But outside of it there is what? There is no overlap. So that's first. So now what can I do? If I think in terms of error that first, E0 plus E2 I can sign with these two. Now what about C0 and C1? Are there parity checks orthogonal of 0 and 1? Yes. 4 and 7. So what we do is 4 and 7. So the 4 one is already here. 7 one is here. What is 7? C0 plus. I will return C1 here. So that's C1 plus C4 plus C6 equals 0. So what can I do with these two guys? So I have to draw the thing carefully. So let me draw it. What can I do with this equation and this equation? I can sign E0 plus E1. From the first two equations I found E0 plus E2. From the next two equations I found E0 plus E1. Then what can I do? Sign E0 for the majority of those two. And always break ties and so on as 0. That is the rule that we always use. We sign E0 plus E2 from the first two equations. E0 plus E1 from the next two equations. Then from E0 from E0 plus E2 and E0 plus E1. Take majority of those two. We'll get again E0. So that is two steps. Let me write that down once again. More formally. So first step I will sign the syndrome R0 plus. Let me return this a little bit here so that I know. R0 plus R2 plus R3 plus R4. I know that this is the same as E0 plus E2 plus E3 plus E4. The second syndrome that I find is R0 plus R1 plus R2 plus R5 and this is the same as E0 plus E1 plus E2 plus E3. And then the third syndrome I find is R0 plus R1 plus R4 plus R6. This is the same as E0 plus E1 plus E4 plus E6. Then when I accept E2, first I will find an estimate for E0 plus E2 hat. I'll call it like this. So it's an estimate for E0 plus E2 hat. What is that? So actually this is not maybe a good idea. So I'll simply say E0 hat plus E2 hat. This is what? This is majority of S1 or S2. And then again, height implies 0. So how do I list that? And then I'll find E0 hat plus E1 hat. What would I find E0 hat plus E1 hat? Majority of S2 S3. Once again, height is in favor of 0. How do I find E0 hat now? Majority of E0 hat plus E2 hat comma E0 hat plus E1. Again, height is in favor of 0. And in every step, if there was only one error, I will always be correct. So overall, if there is one error, I can correct it. And if I have an error, I can correct it. I am not able to answer the question immediately. Maybe you can look at it very closely and the way the palpitations are working out, it may not be able to correct two errors. I'm not sure that's all. So I don't know. I mean it's too complicated to analyze it very simply. So let me just leave it at that. We have to see how exactly the errors will translate. When you can write an exhaustive search to search over all the error patterns and find out which error patterns it can correct. That is one way of doing it. I mean, not in programming, you can do six, seven, four is not a big number. But if you ask me to analyze it, it's a little bit more tricky. There is too much dependence basically. You can't just say this is independent of that amount. So you have to look at it very, very carefully and it may not be worth it at the end of the day. I've tried it in the past for more complicated cases and I never got further than some complicated ones. It's difficult. It's not very easy. Okay. Yes. Okay. So again, the problem there is, yeah, I guess if there are less than j by 2 errors, that might work. So that's an interesting idea. I mean, maybe there are versions of the decoder which use that. Okay. So subsequent things, we don't use the same parity. Okay. So it's a question of how we want to implement also, right? In your implementation, maybe it is more economical to compute all the parities first and then do the measurable ethics, right? So depending on where you are, how fast you want it to be, maybe you want to compute the parities as you go and then keep doing measurable again and again. Then you can do what you're saying. As long as there is less than j by 2 errors, there's no problem. Why was what? The perspective of your process is working out correctly. And one nice thing about what you're suggesting is, as you go forward, your decoder will improve dramatically, right? So what happens in practice also? What's a very interesting question to us? For instance, in Polar codes and all that, which is like I said, is an adaptation of freedom of approach which takes it close to capacity. They use some ideas like that. It's that successive decoder. So you decode one bit first and then use that decoder a bit from the next portion next month. But then the sequencing is very, very important. The first bit you decode, must be able to tolerate a lot of errors. It should have very good protection. So then you decode it and then use it in the next one. The last bit you decode is a better way around. I get mixed up in this, but the sequence in which you do it is critical. That is one thing that's very important. So in Polar codes and all, the main thing is about in what sequence you decode. That is still a bit unknown. People don't know exactly how to do it. What sequence do it? If you do it in the wrong sequence, you'll go for a pass. It will be very bad. So let me step back a little bit. As long as correcting errors within the error-correcting capability is concerned, you can do it in any order. That thing will start. When you want to go beyond the error-correcting capability, like Polar codes and all, you want to get close to capacity, you want to go very beyond the error-correcting capability, you can do sequentially decoding like this to your advantage. But you have to know the right sequence. Knowing the right sequence doesn't seem to be that easy. But there are methods today to know the right sequence. You do the right sequence, then you'll gain a lot. So all that is beyond error-correcting capability. As long as you're within the error-correcting capability, that's all there is. There are no errors in the error-correcting capability. One thing else is that sound is interesting here. So this is major valid decoding. So far I have not explicitly mentioned read-millar code. I've only talked about the a4, three hamming code, but between a and a4, three hamming code is very closely related to the 844 read-millar code. You extend it, you get the 884 read-millar code, and the expansion does not really give you any error-correcting capability, So, we just put it with 743 Hamming code like it is done. So, what we are going to see now is why this will work for an arbitrary read muller code. The same kind of logic, this multiple step majority logic decoding one can show will always work for a read muller code of arbitrary order. So, that is the main result, so the main result is if you want to do read muller code of order r, r comma n, r plus one step majority logic decoding can correct, can correct, r plus 2 power n minus r. So, this is the main result. So, so far we saw one step and two steps, right. If you go to a read muller code of order r and length 2 power n, then you will have to do r plus 1 steps in general. And at the end of the day, you are guaranteed to correct the exact error correcting attribute of the read muller code. So, as you can see the implementation is, when compared to the bellicam messy and all, the complexity and the description of the algorithm are all very simple. There is no finite field involved. It is just another logic decoding. Keep finding some majority again and again, you find parities, find majority, find parities, find majority. It is very simple implementation. There is no complicated equations to solve and all that infinite fields. So, the way it is very simple. And then you will see the implementation is a bit tricky. So, doing it for a general r is not that easy. So, I am trying to give you a theme for why this is true. We may not be able to prove every step. I will try, I will try my best to give you an idea of why this is true. So, this we need a view of the read muller code from a geometric point of view. That is what we are going to see next. And the first result that is needed here. First result you need here of course is the following. So, before that, let me just describe the row on the m as a finite parameter. It has a name. It is called Anglicard as what is known as e t m comma 2. It is easy standing for e t into m. m is for seeking the dimension. Who is there a field size? So, it is looking g of 2. But of course, extensions here e g of m comma 2 power m, 2 power s is also possible. You go to a larger field and then look at its geometry. So, what do you mean by geometry? Geometry means there should be points and lines. Points and curves and planes and lines. That is called geometry. So, you just change your jargon to something like that. It becomes a geometry. So, at the end of the day this is geometry. It is nice to think of it that way. It gives you a nice intuition to think about these things. So, what do you need in a geometry? Basically, you need a set of points. And this is basically 0, 1, 9. So, if you are confused, think of always the real play R2. You have a set of points, an infinite set of points. And then what is next to the geometry? You should be able to define lines and planes and all that. How do you define a line in R2? Set of all x, y that satisfies an equation like A x plus B y plus C equal to 0 or A and B both are not 0. So, that gives you a line in R2. So, a linear equation involving the two variables x and y, one standing for each dimension, gives you a line in R2. So, if you go to R3, what does one linear equation give you? Gives you a plane. What about two linear equations? What do they give you? Assuming that equations are independent, etc. It gives you a line. So, there is generalization of this. If you go to Rn, if you give you one equation, you get what is called the hyper plane. So, it is called the n minus 1 hyper plane. And then if you give n minus 1 equations, you will get the line. But then you have so many other things in the middle. All of them are some objects. You can think of them, all of them as some things. In the finite geometry, those things are called flats. So, it is very common to call them flats instead of planes. They are only a finite number of points. It is not so interesting to call it a plane. So, people call it a flat. Lines are still called lines. Usually, they say flats. It is just a terminology. It is not so critical. So, I will describe the line now. So, a line is basically subset of points. So, first of all, when I have 0, 1, m, I have m dimensions. So, I should have one variable each for each dimension. So, my variables will be v1, v2, vm, same as before. Now, a line will be a subset of points that satisfies a linear equation. So, that is my linear equation. So, let us just say summation ai, vi plus b equals 3. So, i equals 1 to m. And ai is basically 0, 1. Not all ai can be 0. I mean, in that case, we will not put anything interesting. These are so important. So, I should not say it is a line. This is not a line. So, I will remove a line. It is basically what is called an m minus 1 flat. You can also call it a hyperplane. m minus 1 flat is also called a hyperplane. This is just jargon. It is not a critical concept here. It is just a name for a subset of points. So, if you think of geometry very abstractly, you have a set of points. And certain subsets of those points, you give special names. You say a subset is a line. You say a subset is a circle. You say a subset is a parabola. And you just deal with those subsets interestingly, and some nice properties come out for these subsets. Any two lines will intersect only in one point. You define lines that way. You cannot say a parabola is a line. And then you will have two parabolas intersecting two points. It becomes crazy. So, you have some structures which you define for those sets, and then some properties that come because of it, and then you study them. Similar things will happen here. If you have two hyperplanes, that can be intersected. So, what is two hyperplanes? One hyperplane is one equation. Another hyperplane is another equation. So, if you put both equations together, what will you get? You will get an m minus 2 flag. So, two m minus 1 flags will intersect in a m minus 2 flag. Two m minus 2 flags will intersect in a, depends. So, we will look at it a little bit closely. It depends on the equation. So, assuming that are independent, it can go to m minus 4. It can be m minus 3, etc. Is it okay? So, that is the way to think about it. They can intersect in so many different ways. So, just put the equations together. You will get these things. So, this is an m minus 1 flag. Now, in general, you have an m minus r flag. An m minus r flag, p, p and p2 will be basically set of points satisfying r equations. What are these equations? They are linear equations. So, it has to be linear. So, each equation should be active. You can't just repeat the same equation twice. So, it is important. Each equation should be active. So, you can't have, there should be some linear independence between the equations. They should enforce something. So, these are r equations and m minus r flag. So, let me give you an example. So, an example here will probably be useful. So, let's say, let's take eg1,3 that's the most interesting example. There are 8 points, 0,000. You can think of so many lines. For instance, you can say v1 plus v2 plus 1,000. So, what is this line? This is a line. This is not a line. This is actually a hyper plane. So, it's a 2-slap. So, I do that correctly, 3 comma 2. So, eg of 3 comma 2. This question is, set of times 0 and 3. The variables are v1,3,4,v3. So, I say v1 plus v2 equal to 0, I have a 2-slap. Whether there are various points, you can just list it out. It's not very hard. So, v3 can be arbitrary. v1 and v2 have to be, have to x out to 1. So, you can have it as 0, 1, 0. 0, 1, 1. 1, 0, 0. 1, 0, 1. In general, how many points will an m minus r flag have? You have n variables. You have only r equations. You have 2-slap, m minus r. So, that also makes sense. A 2-slap has 4 points. So, if you want a 1-slap, what should you do? You put one more equation. So, look for v1 plus v2 plus 1 equal to 0. And then you say v1 equal to 0. So, you will get only 0, 1, 0, and 0, 1, 0. So, you see, just like lines can be contained in planes, 1-slaps will definitely be contained in 2-slaps. There's no problem. If you have a 1-slap, it will be contained in 2-slaps. So, how many 2-slaps will contain a 1-slap in this? How many 2-slaps will contain a 1-slap like this? So, it's an interesting question to think about. There are so many other parameters. So, those are things that are important. So, for our analysis, questions like that are important. How many 1-slaps will be contained in a 2-slap? So, it's ridiculous class of questions in R2. It's everything with infinity in R3. So, how many planes will contain a line? Again, you will say infinity. So, here it's not infinity. Everything is finite. There's only a finite number of points. So, before that, let me ask you another question. How many m minus r-flags are there in EG of m comma 2? Can you answer that question? How many m minus r-flags are there in EG of m comma 2? So, it should be castle bar. So, because you might be counting multiple times, same thing. So, you should not do that. Because if you just multiply by some linear equation on the side, you'll get the same thing. So, you also need some linear independence there. It's a computation. But there are answers to such questions. You can answer all those questions. You can come up with numbers for all those questions. Very simple numbers. How many 1-flags are there in a 2-flag? It should be a very simple answer. How many 2-flags contain a given 1-flag? That is a very simple answer for it. I will not do the computations yet. Maybe in your tutorial, there will be some questions. That is totally optional. You don't need to know the numbers yet. Just remember that these numbers can be accurately computed. And it's a very simple computation. It's not a complicated computation. It's thinkable for a while. You'll get the answer. What is the question? I don't want any 2-flags m minus r-flags I did. No, no, no. It won't be true. That's not true. Unfortunately, it's not true. So, it's not that rich. It's not like that. So, any set of points on r2 do not form a line. It says infinity. But here also, you can't say that. It's a set of points on r2 do not form a line. 2 only. Yes. So, if you say between any 2 points in EG of 3, 2, there will be a line. That is true. Any 2-flags m minus r-flags contain more than m minus r-flags? It's not 2-flags m minus r-flags. It's m minus r-flags. If you have m minus r-flags, you're right. If you have m minus r-flags, I think something m minus r-flags. If you have m minus r-flags, then through it, you can write an equation. So, it's easy to write those equations. You can write an equation involving all those points and have m minus r-flags through them. So, it's just, I mean, this is a bit complicated. I'm not doing it in detail. I know that. We don't really need to know the depths of these things. We only need to know some basic definitions and some equations like this. The reason why this is interesting for us is, once you have an m minus r-flag, you can go from the m minus r-flag to a code word of a read molecule. That's what's interesting. In terms of what are known as incidence vectors. So, if you have a subset, you can also define an incidence vector for a subset. What's an incidence vector for a subset? You have a set of all points. If you have a subset, wherever the elements of the subsets are there, you'll have a 1. Outside of that, you'll have a 0. So, you can form a 2 power m length vector from every subset. It turns out those vectors of m minus r-flags are code words of the read molecule. So, that's why it's interesting. I'll describe this in more detail in the next class. Running out of time. So, it turns out m minus r-flags are very, very closely connected to code words of the read molecule, r, m, r, r, r, r, r, r, r. So, that's why it's interesting to us. And it turns out these flats play an important role in giving us parity checks which can be used for read molecular code decoding. So, these m minus r-flags are very nice objects in the finite geometry which uses good code words and parity checks for my read molecule. So, we'll see that in the next class. If you're interested, there are lots of resources to read about these things. There are lots of interesting finite geometrics. There's one geometry called the Sano plane, which is really, really, very, very interesting. So, it's related to the simplex code that we had before. So, there are lots of interesting finite geometries also. It's not just up to, it's not the only interesting geometry. Okay, so we can do that. So, next class, I'll tell you what the connection between these m minus r-flags and read molecular codes is. You see, the connection is very simple. There's just one equation, right? You can add one on both sides. So, we'll get a one equals something equation. Can you multiply all of them together? We'll get a degree r polynomial. Okay? And all these points are the degree r polynomial. And that's exactly how we define the read molecular code. So, all these m minus r-flags must be there in the read molecular code. So, it's a very simple idea that gives you a powerful connection. Okay? So, I'll tell you that in the next class. Okay? Stop here.