OK so we're going to talk about some ways to send the message efficiently.
One way would just be to check a parody of something and then send it along.
So for instance this is the message and the parody is going to be that's 1 1 1 1 0 0 because there's
four of them.
The parody is yours.
I just add that to the end and then if this one of them was off he could do that now.
It wouldn't check if there were two that were off.
And if this was a zero then it should be a 1.
But it's not OK.
So you could do a bunch of them together you could send for each part of the message you could send
something like this and put it together.
So for instance if you had this and it's one two three four five that's a one.
If I had one two or three events or one and that's a one so I can send this but I can also send along
the parody here which would be one two three four.
That's a zero zero one.
That's two.
So that's 0.
That's 1 so that's a 1 and that's 1 2 3 so that's a 1.
And so you can see that it's the same and therefore I can send this message with the Zero this message
with the one that is measured with this.
Or I could send these messages one two three for them this and this.
And then if you have an error somewhere for instance if you want to see that you know for instance this
ends up being the wrong thing it ends up being a one and the wrong color they're trying to differentiate
to show you.
So change the color.
So if this ends up being a 1.
So now this line is one two three four that's off.
And this line is off.
And so therefore I know it's at the spot that's in between those two.
So that would be one way to check you know the message.
Now we have another system called cyclic redundancy check.
There are different variations of this.
You pick a polynomial we can pick this one that represents x squared plus zero x plus 1.
That's a polynomial that we can pick it's represented by this.
If we pick this polynomial that would represent x to y 0 1 2 3 4 so that x x to the four plus this spot
is so that's X of the 4 spot 3 to 1 plus X plus 1.
That would be representative of that polynomial.
What we're doing is we're doing division and we just add on the remainder here.
So I'm going to take the first one and I'm going to get a message and my message will be just a bunch
of numbers and letters or numbers with who are doing letters it would be in binary and hex or something
like that.
But this is my message and I'm going to use this polynomial of 0 1.
So let me just do this so here's my message and what I'm going to do is I'm going to or with my polynomial.
So I do that so x4 that 000.
Then I carry the rest down.
And then I write my polynomial again an X or so that 00 and I have this and then I write my polynomial
again.
I keep going till the end.
They write my polynomial at 0 1 0.
This is the remainder right there.
So you just attach it on over there.
We could just attach it on 1 0.
Kind of hard to see got to pick something different there.
1 0 that's my remainder.
This is my message.
OK so send message with remainder.
Now the beauty of this is that all you need to know is that remainder because at the end if we do the
same thing if we were to now take the same thing this whole polynomial and do it 1 0 0 1 0 etc. what's
going to be the difference over here.
This one zero gets carried down this one zero gets carried down and then we're left with make it's a
drop lower so we can see it to do two you know.
OK.
We're left with 1 1 so this is here then we're left with this k.
Now I take my 1 0 1.
So this is what I'm left with just to make it clear.
And I extra with that and I get 0 0 0 because then the remainder is taken care of.
So essentially what we're doing is we are just checking for the remainder.
We're adding it you know sending it along and then making sure that your polynomial has the same remainder.
That's it.
There's all kinds of variations of this.
You know you could do all kinds of things X or I'm just going at it on.
But you know you could do lots of stuff but this is your cyclic redundancy check because it's checking
for any.
It's just cyclically doing this now it's very fast.
Why.
Because it is doing shifting.
This is how you write it in code there's a lot of lot of details but is not necessary for now suing
shifting and X all of which are superfast operations which is why that's X or doing superfast operations
which is why it's such a good thing and it can you know check 99 percent or whatever it is of errors
you know really really quickly and efficiently.
There you go CRC.