 Okay, so this is lecture 23, so roughly I think we are halfway into the course and we are doing fine, thought we will be too slow but we are doing fine. Okay, so this class is going to be an illustration of the Wittebi algorithm. We will see an example, a couple of examples and maybe some quick ways of bounding probability of error. Okay, so that will be this class. Okay, so I am going to start with the simplest example out there for the Wittebi algorithm, which is this mz being 1 by root 2 minus 1 by root 2 z inverse and what is my mz going to be? It is basically, what is my mz? Let me see, it is the equivalent causal monic response. So I am doing a spectral factorization on my sieve pulse and the monic causal part is mz. So I am going to say my transmit constellation is ppsk plus minus 1. So that is going to be my transmit constellation. So the picture you should have in mind is symbols are coming in into mz, it is getting filtered by mz and you obtain received symbols to which noise gets added and then you receive something zk and you already code based on zk. So I am going to take an example situation, it is quite simple. So if you do a trellis for this, you will get a two state trellis. So I am going to draw a very simple case where there are three stages and one termination stage, three data stages and one termination stage. So if you draw the trellis for this, it would look something like this, that would be the trellis. And like I said typically you work with a certain zk which was received. So I am going to say zk is so the transmitted symbols are either 0 minus root 2 plus root 2. So we will take roughly root 2 as, what can we take root 2 to be roughly as 1.4. So I am going to take root 2 as 1.4, then 1.4, minus 1.4 as 0 gets transmitted and I am going to receive that signal corrupted by noise. So that is what is going to happen. So I am going to take minus 1.1, then 0.3, then minus 0.5, then 1.6. So those are my received values. I am trying to decode, remember how many symbols have I transmitted? If I have a trellis like this for decoding, how many symbols have I transmitted? Yeah, it is only three data symbols. The last one was a termination symbol. So the sk would have length 3, bk would have length 4, sk 3 plus that extra plus 1 which was for termination. That was my sk. So I will quickly write down the outputs corresponding to each branch below the branch and we will write down the branch metric above the branch. So the output corresponding to each thing is this. So once I write for one complete stage that is good enough. We do not have to keep writing for the whole thing. So the first exercise is to compute branch metric for each branch. So go ahead and do that. Done, we see enough. So I am going to write down the branch metric up on top. Let me know if I make any mistakes. 2.21, no? 1.21. Am I right? 1.21, right? 1.89, 2.89, 1.7, right? It is numbers below are a little bit distracting. So 1.9 is 3.69, right? Am I right? I am sorry. Oh, okay, okay. So that is going to be 0.81, yeah, right? This one will be 3.69, 6.1, no? Okay. So this would be 1.6 square which is 2.56, and then 0.04, okay? How many of you think you can eyeball the ML path without doing any Viterbi? It is two test relays with four stages. You should quickly eyeball the minimum path, right? So it is absolutely nothing in this. But anyway, we will run the Viterbi and we will do maybe a slightly more complicated example the next time, okay? All right. So how does the Viterbi work? So you start with the state metric assignment and then update the state metrics and the side-over paths stage by stage, okay? So initial state metric that you assign is 0 for the known state before state 0. After that, if you look at this guy here, okay, plus 1, right? If you look at this plus 1, I don't know if we can look at my marker, it is a little bit too tiny. If you look at the plus 1, there is only one branch coming into it, okay? So obviously that has to be the side-over. There is no real choice, okay? In your minimum, there is no problem. And the branch metric would be 1.21 and that would be the survivor. So I will take, I will put a red ink on the survivor, okay? Likewise here, the state metric would be 0.09 and the survivor would be just that one path, there is no choice, okay? Now you start getting choices, okay? But the minimization is easy enough because you have only two paths coming into it, right? If you look at this plus 1, okay? I will put a question mark here. So this is the one I am looking at right now. There are two possible ways in which they could have come in. If I take the top route, right? The path metric becomes 1.3. If you take the bottom route, thing becomes what? No, no, no, no. 1.3 again, okay? So the bottom one is 1.3 again, okay? So I have to make a choice. What choice shall we make? Okay? So it turns out in those kind of situations, you can choose anything. You can't go wrong, okay? Right? The ML path is anyone. So we will pick the top one, okay? So top is always better. So we will pick the top one, survivor, okay? So down below, if you come here, what happens, right? Yeah, 0.18 and the bottom path, okay? So that is clearly the survivor, right? The other one is just too much. It goes to some 3.1 or some 4.1, okay? So you don't have to worry about it, right? So notice several things, okay? So at the end of the first stage, right here, okay? You have only two possible paths, okay? Total number of paths up to that point is only two. And you kept track of both paths. Right here, how many paths do we have totally in the trellis up to that point? Four different paths. Do you see that? Right? Two different inputs, four different paths, okay? That's how you compute it. You don't have to go through the trellis and compute. But how many paths are we keeping track of? Only two. So I've already eliminated two paths and that will continue stage by stage. In every stage, I'll eliminate half the paths. I'll only keep track of the remaining half which are survivors. So that's where the savings is coming. So that the way I remember the way I split all the paths as unions of several things. That I'm doing stage by stage. So I'm only keeping track of those paths that are important for me, okay? So let's go through here. Once again here, it's quite easy. This is going to be what? 1.56 and the top path. This is going to be zero point. What is it? Four three, no? Am I right? Okay? And the bottom path. 1.55, yeah? Thought I had 1.30. That is okay. So for some reason I wrote three. Okay, that's okay. It's not a big deal. But okay? So once again, I want to point out that at this point, you should have actually had eight different paths but you're only keeping track of two. Okay? So if you did not have termination, okay? What would you do here? Okay, so that's the question. If you did not have termination, you have two paths, one with metric 0.43, another with metric 1.55. If you did not have termination, what would you do? Yeah. So one decision to say is of these two paths, I'll take the one with lower metric, but that's not supposed to be ML. I mean, it's not really clear whether there's some other path that would have ended in this stage with lower than 1.55, right? So I mean, well, in this case, maybe it's too easy. But when you have more states and all that, you can't really decide between paths that are ending in those states. Okay? So because you can't compare a path that is ending in this state with the path that is ending in that state and throw one out, because you don't know everything is ending at the same path. Right? So you can't do that. Okay? So that's the problem. So you can't really decide, but there are practical algorithms where people just pick the lowest path at this point. But usually there is termination. So you can go through for the next one and you will get only one path as the ML path. Okay? So when there's termination here, once again, it's very easy to see. This is 0.47 and the bottom path. Okay? So now you backtrack and write down your SCAP as what? It's going to be minus 1, minus 1. Okay? So it's away from ZK by a metric 0.47. And every other path in the trellis would have a metric which is larger than that. That much I'm guaranteed. Right? This is the closest that I can get to ZK on the trellis. Okay? So that's what my Viterbi algorithm guaranteed. All right? So this is how we run the Viterbi and it's quite simple. In most cases, it's no real problem. But we're going to do one more example just for complicating matters and driving home some points. It's important to do that. And the next example I also wanted to do because we will use it for some analysis later on. Okay? So it's slightly more painful example but I think it's good to do that. Okay? Just to point out that the Viterbi can get really complicated once the number of states increase. Okay? So here we're going to take M of Z to be 1 by root 2. Okay? So what we'll do is we'll do this. Just to make the metrics easier, I'll get rid of all these root 2s. I'll just simply take an M of Z. Okay? But it may not be monic. It may not be normalized to 1. It may not be minimum phase. Nothing like that. Okay? I'm not guaranteeing this. For example, I'm taking this. Okay? So we'll take 1 minus Z inverse plus Z comma minus 2. Okay? Well, it is monic but I don't know. Maybe some of you can do a quick computation and tell me if it's minimum phase or not. Okay? I'll take BPSK. By the way, how do you find if this is minimum phase or not? Find the zeros and the poles. Okay? All of them are inside the unit circle. Then it is. Okay? What do you think? Do you think this will have poles? Okay? There are no poles, right? It's no question of poles. What about zeros? Where will the zeros be? It'll have two zeros on the unit circle, right? So it is. This, is it? Am I right? Will it have two zeros on the unit circle? No? Why will it have? Okay? Okay. Anyway, think about it. I think this is the factor of 1 minus or 1 plus Z power minus 3, right? So, so you can figure out where it will have. I think it has two zeros on the unit circle. That's what I think because, anyway, check it out. Doesn't matter. Okay? So, let's do, so, so, so now the number of states is what? Four. Okay? We did the trillis before. The number of states is four. So, I'm going to, since the number of states is four, I'm going to take a very, very simple example to make sure my life is very simple. So, I'm going to just take maybe two or three symbols once again, depending on how much space we have on the board. Okay? So, that's going to be the limitation. Okay? So, the known state at the beginning will take as 1, 1. Okay? And then it will transition into two different possibilities, 1, 1 or minus 1, 1. It's a first trillis. Then it will transition into again, 1, 1, 1 minus 1, 1 minus 1, 1 minus 1, minus 1. Okay? And then finally, the stage will become complete. Okay? All right? So, if you notice, there's a subtle thing I did. What is the subtle thing I did in the ordering of the states? Okay? Yeah. So, the first possibility here, the state, what did I do for that state? I chose it as the third state. Okay? So, you might say, there's some, just makes my diagram maybe look a little bit prettier. Okay? So, those are things you might want to pay attention to. It's okay. You don't have to do it. Right? Even if you do it, the other way, it will work. It will give you a valid trillis, but it might become a little bit more ugly. All right? So, okay. So, I think I'm going to terminate right after this. Okay? So, it's going to be plus 1, plus 1, then plus 1 again. Okay? So, the trillis is fine. Okay? So, we'll write down the outputs below the branch in the complete stage. Okay? And that should give you, okay? What are the outputs? Top here, 1 minus 1. Is that fine? Minus 1. This one is what? Minus 3. Okay? 3 and 1, 1 and minus 1. Okay? Those are the outputs. Check and make sure I've not made any mistakes. Is it okay? It's no, maybe? Yeah, 1, no? No, it's 1. Is it okay? I'm not getting enough heads to nod. Let me see. I'm sorry, 3. 3 is wrong. No, those are the outputs corresponding to each branch. At that time, writing below the branch. It's not metric or anything. Okay? Why am I writing it in this stage and not here? Yeah, so it's all the same. Also, this stage has all the branches, right? This stage doesn't have some branch and then as I go along, I'll have to do it. So, take one complete stage and then write down all the outputs below the branch. Okay? So, then whenever you have to compute the branch metric, you can quickly look at that output and then use that for computing. It's very easy to do that. So, okay? So, now I have to give you the Z case. Z case, I'm going to write on top. Okay? Next to the stage. Okay? So, these are things you can use. It's not too bad. Okay? So, I'm going to say 0.8. Okay? Minus 1.1. Okay? 2.6. Okay? Minus 0.9. And then 0.5. Okay? So, those are my Z case. All right? So, the next job is what? Once you have the Z case, write the branch metrics. Okay? Go ahead and do that. So, let me move my Z case a little bit further away so that, so you see already it's becoming painful if you have to compute all the branch metrics without doing the sub-weaver part. So, it's probably best to just compute the branch metrics as you go along instead of computing it ahead of time. Okay? So, if you do that, here it's going to be 0.04. Am I right? And down below it's going to be 1.8 square is what? Sorry? 3.24. Is that fine? Okay. So, likewise, keep going along. 2.1 I believe is 4.41. Okay? Here would be 0.01. Okay? 4.1 squared would be what? So, as we say it's roughly 16. Okay? 17.61. Okay, good. I don't know. It's okay. 17.61 is good enough. 16.81. Okay? So, there you go. That's the right answer for 4.1 squared. Okay? And then 2.1 again would be 4.41. Okay? Alright? So, let's do something now. Okay? Just to simplify matters. Okay? What's the branch metric? Mod Z k minus B k squared. Oh, that will split into mod Z k squared plus mod B k squared minus 2 times B k Z k. Okay? So, we can write that as what? So, mod Z k squared we can definitely ignore. Right? So, we can write that as mod B k squared minus 2 times Z k B k. Okay? So, if you want to further split this, it's going to be B k times B k minus 2 Z k. Okay? So, this is a computation which is probably slightly simpler than the other computation. Okay? So, can I do it just arbitrarily starting at this stage? Can I use this different formula only for this stage? Yes? Yes or no? Yes, I can. Right? So, I can do whatever I want because as long as I am consistent in each stage, I can subtract any quantity that is constant because the way I compare my path matrix, I am doing it stage by stage and everything will pay the same penalty. So, I am okay. All right? So, that's important. Okay? So, let's see. Maybe this calculation is easier. It's tougher. Okay? So, I don't know. Yeah. So, maybe the squaring is easier. Okay? So, 1.6 square is 2.56. 3.6 square is what? 12. Okay? Good. So, there you go. We'll go through and do a lot of computation. Okay? Once again, 3.6. Okay? 5.6 square. Okay? Sorry? Oh, you have a calculator. Okay? So, 30. 3.6. Good. So, this is 0.4 which is 0.16. Okay? So, this is 2.56. So, one thing I want you to notice is what? What is one thing you can notice here? Yeah, a lot of calculations are being repeated. The reason is there are only four different outputs possible for eight different branches, right? What are the four outputs? Plus or minus one, plus or minus three. In fact, plus or minus three occurs only for two. So, one and minus one occurs for a lot of these things. So, it's enough if you compute four of these squares and quickly write down the remaining. Yes. It's not a big problem. So, let's go through here. 1.9 is 3.61. Am I right? And then 0.01. Okay? Then what? 3.9. There you go. That's another interesting square to compute. Sorry? 15.21. 15.21. There you go. Then you have 1.9 again which is 3.61. Right? So, finally, we have an easy calculation which is 0.25 and 2.25. Okay? So, who's going to eyeball the ML path? So, it's a dangerous game to play, but you can do it in this case also. Because when I gave you the Z case, I looked at the outputs and biased it towards, made it very close towards one path which I wanted to take. So, that's why it's becoming very easy. If I had picked my ZK randomly, it would have been much more difficult to find the ML path. You'll have to actually do the Witter B. Okay? So, let's do Witter B. If you do the Witter B, you're going to start with the state metric 0 on the leftmost side. Okay? The state metric here is going to be 0.04. Here it's going to be 3.24. Okay? So, the survivors are going to be full here. Okay? So, the next state also, you have only one path going into each state, right? Right? So, notice that. So, this is going to be 4.45. This is going to be some huge number. Okay? So, I think it's 19, no, 20.05. Okay? So, this one is 0.05. This one is 6.6. So, 7.65. Is that fine? And if you write down the survivor path, this is what's going to be. So, you have four survivor paths and that is something which in general will be true. What is the general statement we can make now? If you have psi mu state Witter B, implies what? Right? At stage mu, after stage mu, you will have exactly psi mu paths, survivor paths. Okay? So, psi mu, stage mu is complete. Okay? Let me not say it's complete. It's a weird statement. Stage mu results in psi mu paths, survivors. Okay? After that, what will happen? There will be only size, size x power mu, psi-waver paths after that. After that, it will not increase. Okay? So, usually you will expect that to double after that, but it doesn't double after that. It becomes a constant. Okay? Let's go through here. Here, it's going to be 4.45 plus 2.56, which is 7.01. Okay? Here, you would get 0.21. Here, you get 17.41. Here, you get 2.61. Okay? And what are the paths? Okay? Here, you have this guy. Here, you have this guy. And here, you have what? I'm sorry, 37, no? 17.37, is it? Okay. It's okay. I'm just... Is it okay? So, make sure... How can it be 17.37, man? That's the end in a 1, no? Maybe 3-1. 17.41, no? For once, I'm doing it correctly, huh? Yeah, I know. There are 2 million numbers. Okay. So, I want to make a few observations about what's happening to the survivor paths at this time. Okay? So, write down the 4 survivor paths as a sequence of states. Okay? Can you do that? So, number the states is 0, 1, 2, 3. Okay? 1, 2, 3, 4. Don't do anything else. If you write down the survivor paths... survivor paths... Okay? So, what's happening? You'll observe something that's slightly interesting. What has happened to the 4 survivor paths? What are the 4 survivor paths? 1, 1, 1, 1. Okay? So, the first survivor path is 1, 1, 1, 1. What is the second survivor path? 1, 1, 3, 2. What is the next survivor path? I'm sorry? 1, 1, 1, 3. What is the last survivor path? 1, 1, 3, 4. Okay? So, those are the 4 survivor paths after stage 3. Well, stage 2. 0, 1, 2. Right? So, the first thing you'll notice about survivor paths ending at... after any stage is what? This entry, the last entry is very easy to predict. What will the last entry be? 1, 2, 3, 4. Right? In the same sequence, it will come. Okay? There's no... There's nothing there in that thing. The last state for survivor path has to be that state itself, whichever state you're in. Okay? So, there's no problem. Okay? So, what's interesting about the previous things? What has happened? Do you notice anything interesting? I'm sorry? Yeah. So, the survivor paths have merged in the first stage. Okay? So, what does it mean? So, I know in my ML path is going to be one of these 4. Right? Right? Finally, the ML path will be one of these 4. So, what can I say even at this point, even before I go through and complete the whole thing? I can make my ML decision for the zeroth stage. What will be my ML decision for the zeroth stage? Plus 1. My escape for the zeroth stage is going to be plus 1. I know for sure why. Because all my survivors have merged at that stage and that corresponds to a plus 1 transition. Okay? So, that is something that is interesting which happens in a Witter B, which helps us in terms of complexity. Do you see why? Why would this help us in terms of complexity? Exactly. So, what's happening is when you actually run the Witter B for say L equals 1000 or something for 1000 symbols, you will have to store these paths for 1000 stages. Okay? So, what's expected in Witter B is once you progress a little further, your survivor paths would have merged a little further behind, which means from there you can actually make a decision and finish it off. You do not have to wait till you fully complete. So, in terms of complexity, in terms of memory and also in terms of what? In terms of the latency that you encounter before you can make decisions, this merging of the survivor path is an important event that happens. Okay? So, typically what happens is people have some ballpark number like 4 times mu. Okay? If you progressed for say small k stages, k minus 4 mu at that point the survivor paths would have merged is one theory. Okay? So, based on simulations, people have that understanding. Okay? So, if you do not have that thing, if you have to keep track of all these survivor paths and figure out where they are merging. Okay? So, that's an interesting thing to do. Think about how you would program it. Okay? If you have to store all these survivor paths, what data structure will you use for their storage so that you know when they have merged? Right? Can you do that? Anyone here who has done programming with these kind of things before? So, you think about it. So, is it possible to store these things efficiently in some structured way so that when they have merged a certain distance behind, you will automatically know it's easy to find. Okay? It's difficult. It's not that easy, but maybe it's doable. Okay? So, think about it. Okay? So, that's some possibility there. All right? So, this merging is quite crucial in terms of reducing complexity and all that. Okay? So, let's proceed to the next stage. It's quite easy to do from now on. Okay? So, you do this. From now on, it's automatic. Right? There's no decision because if I sent only three data, if I send more data, there'll be decisions. From now on, there is no decision. Do you see that? Okay? Just because there's no decision, you can't say I'll decide on the several path here. Why? Because the metrics are adding up. You have to compare the metric till the last point. Am I right? Am I right or am I wrong? No, you still have to make decisions. Okay? So, look at this state. There are two possible paths. You'll have to decide on the one that's coming below and then you get point 22. Okay? So, it's much easier but still one needs to do some work. Okay? So, what is this? 6.22 in the survivor path. That's the one that came from below. Okay? The next one is much easier again. It's 0.47. Okay? So, miracle of miracles. We have the same minimum metric as the previous example. Okay? Did we get that? Did we get 0.47 for the previous one or? Okay? So, this is called the freak of nature. Okay? So, once you do that, you can decide S cap. What is S cap going to be? Plus 1. Minus 1. Plus 1. That's it. Okay? The remaining two I know for sure are plus 1s. Alright? Okay? So, that's a slightly more complicated example. If I had one more stage with data, you would have had to do real more complicated operations for one more stage and that becomes the problem. Alright? So, in practice when you're running, if at all you want to run beta B, so for a long stretch of data, there are a lot of issues you have to worry about. Okay? So, let me try to point out a few issues. First issue is some implementation issues which you might have to worry about. Okay? I pointed these out even the last time around but I want to just go through that. First thing is storage. Okay? What all do you need storage for? What all need storing? What's the crucial thing that needs storing? Okay? The survivor paths have to be stored. Okay? So, that will pretty much be the overwhelming storage requirement. Okay? What else needs to be stored? See, the branch metric may not be stored, right? When you come to a particular stage, you compute the branch metrics, right? And then you use the use the same memory. Okay? Even the state metrics need not be stored. You only have to store them for two of them. Okay? So, the survivor path memory will pretty much dominate your requirement. Okay? So, what people do to... So, if your length increases, if you have to decode 1000 symbols, then your survivor path might become too large. Okay? So, what people do to combat that is use some notion of what's called decoding depth. Roughly, this is chosen to be, say, some 6 times mu. Okay? So, that's just a ballpark number where 5 times mu might be good. You'll have to do simulations to check these things. But maybe 6 times mu is a good number to pick. Okay? So, what does that mean when I say 6 times mu? Okay? So, I start at stage 0. I proceed up to some stage K. Okay? I store my survivor paths. I look 6 mu behind. Okay? So, this is K minus 6 mu. Okay? I'll kind of decide at this time that survivor paths have merged at this point. Okay? Okay? Seems like a reasonable decision to make. If you have some data structure which is turning on and saying, hey, the survivor paths have merged here, then you can make a decision without any problems. But usually, it's difficult, at least in VLSA and all that and hardware to build such data structures. So, people don't do that. You just pick a 6 mu and say, at this point, the survivor paths have merged. So, how do I decide? How do I decide on those things? You take any one of those paths that are surviving here, go 6 mu back and output that. That's it. And then what can I do? I can throw away this memory and start storing only from this. Okay? So, you see in DSPs and digital signal processors which say they can that can implement Viterbi, they'll have the circular buffers. Okay? So, your old buffer will have length only K. And after that, you'll start rewriting from the beginning. So, you'll keep writing in a circular buffer and you'll have a flag which shows what the 0th position is and you'll implement it. Okay? So, this is how decoding depth is done. So, you go up to K and then K minus 6 mu we design. Okay? So, it's slightly suboptimal, but you can do simulations and other arguments to show that it has to work. And if you know that the survivor paths have merged, there's nothing suboptimal about it. It's exactly optimal. Okay? So, that's one thing to minimize your stories. The other problem we will have is in overflow for state metrics. Right? As your L becomes larger and larger or even your K becomes larger and larger in what you're deciding. Right? You'll have an overflow problem. As in what do I mean? The state metric keeps on accumulating. You saw before some of the values can become very large. Okay? So, usually you should imagine these state metrics are stored in fixed point format. Okay? So, you can't have a huge dynamic range. Everything is possible, not possible. So, what people do is usually they subtract a constant and keep making sure that the state metric lies within some range so that they have good presentation. Okay? So, you basically subtract a constant at each stage. Okay? So, the third problem is one of latency. Okay? So, the decoding depth actually also takes care of this latency issue. Right? If you did not have a decoding depth. Okay? So, you would have to go through the entire sequence before outputting the first one and that might be too much latency for you to tolerate in the communication system. You might expect the results to come out much faster. Okay? So, for that decoding depth to an extent, solves the problem. Solves the problem to an extent. But even otherwise, naturally, the bitter B seems to be a very sequential algorithm which cannot be run in parallel. What do I mean by parallel? Suppose I receive a sequence of L outputs. I can't start decoding the 0th and the 10th and the 11th or 12th at the same time. Right? I have to start at 0 and only when I've decoded everything I can proceed. Okay? So, that also is a problem. Parallelism is a problem and there are solutions for parallelism as well. So, this is an interesting solution. Again, uses the properties of the bitter B algorithm. Suppose you have a very long sequence that has been received. What people do is split it up into different windows and you let the windows overlap. Okay? So, here you have the first window. Right? This will be the first window. Okay? The second window will overlap by say some 4 mu or some such ballpark number. Okay? With the first window. This is the second window and so on. Okay? The successive windows will overlap by 4 mu or 6 mu or whatever number you pick. So, now what will happen is you'll start here as well as here in parallel. Okay? So, here you assume you know what the initial state was. So, you know how to put the 0th state metric. Here what will you do to start off? You don't know anything, right? So, you don't know the metrics there. So, what you'll do is you'll put 0 for everything. Okay? You'll put equal state metric, 0 for everything and start. By the time you have run through to 4 mu or 6 mu stages, what would have happened? There will be significant difference between the state metrics and somehow the memory would have taken care of it and you would have obtained some advantage from the bitter B. Okay? So, even though you made a suboptimal choice of all 0 state metrics at this point, you should not know, but you wanted to start ahead of time because you wanted to run both in parallel, right? So, so that you can decode very fast. So, but by the time you run through 4 mu stages in the second window, there would have been enough metric that would have picked up and the erroneous parts would have been had larger metrics and the valid part probably would have had shorter metric and there would be enough differentiation and the state metrics here might be accurate. Okay? So, the state metrics here might be okay. Okay? By the time you start there. Okay? So, you go through, run your second window and when you make decisions on your second window, you stop up to this point. You don't go all the way back to the 4 mu. Okay? Do you see that? Okay? So, is this clear or? It's definitely not clear. Okay? So, so when I make decisions, when I trace back, how do I trace back? I don't trace back all the way to the beginning of my window. I stop here. Okay? So, the second window, right? Okay? So, let me say this is 0. This is maybe L1. Okay? So, this is L1 minus 4 mu. This is L2. Okay? So, the first window works on stages 0 to L1 plus 4 mu. Okay? So, it's actually work L1 plus. Okay? Let me say 8 mu here. Be very careful. So, maybe, maybe 4 mu. Okay? So, that's fine. Okay? So, it works from stages 0 to L1 plus 4 mu. Second window would work from? No, wait. I'll come back to it. I'll come back to it. Stages L1 minus 4 mu to what? L2 plus 4 mu. Okay? So, why am I doing this 4 mu, 6 mu? Okay? I want some enough decoding depth to decide for stage L1. Okay? So, this is what the Witter B will run. So, this is for just the running. Okay? So, if you look at decisions, this is just the Witter B. If you look at decisions, right? Okay? The decisions for the first window will be from what to what? 0 to L1 minus. No, no, no. 0 to L1. Okay? The second window will be L1 plus 1 to L2. Do you see that? Okay? So, remember every time if I want to make a decision on stage K, I should have run my Witter B forward till K plus 4 mu or 6 mu or some such thing. And only then can I make a decision on stage K. Okay? So, I want my first window to run so that I can make decisions from 0 to L1, which means the first window actually should run forward for L1 plus 4 mu, then I can use my decoding depth and make a decision. Okay? But for my second window to start, even my initial metric is bad. Okay? So, when I run actually for the decoding depth, only my last metric will be bad. So, I am running through because I have not terminated, right? So, I am running through further and coming back. But for my second window, even the starting point is bad. So, I cannot start where I want to decide. I have to start 4 mu or 6 mu before run through. I know there will be some overlap. It seems like wasteful decisions, but you have to work with that if you want more parallelism in your Witter B. Okay? So, this is called the windowed Witter B. Okay? And today's wireless systems, for instance, try to use windowed Witter Bs because you want faster data rates, right? So, you do not want, you know, you want faster data rates. Everything has to go fast. So, you implement windowed versions of these algorithms and practice today. Okay? So, it is considered much better. Okay? So, I will stop here for now. I think this is pretty much all I wanted to say in terms of Witter B. And next class, we will pick up on some simple analysis and we will proceed further with you.