Anda di halaman 1dari 9

Introduccin a los cdigos correctores de errores : Cdigos Reed-Solomon 1.

- Cdigos y la correccin de errores :


La funcin principal de las tcnicas de control de errores es introducir redundancia controlada permitiendo que los mensajes transmitidos que hayan sido corrompidos sean corregidos antes de ser procesados. Con esta redundancia controlada slo un subconjunto de todos los posibles mensajes (secuencias de bits) contiene mensajes vlidos. Esto quiere decir que si formamos secuencias de 7 bits, podremos recibir 27=128 secuencias distintas, pero los posibles mensajes transmitidos no sern 128 sino un subconjunto de ellos, luego si no hemos recibido una secuencia de 7 bits que coincida con uno de los posibles mensajes transmitidos, habremos recibido una secuencia con errores. Este subconjunto de posibles mensajes transmitidos se llama cdigo y a los mensajes vlidos que lo forman los llamamos codewords o codevectors. Pues bien, un buen cdigo es aquel en el que los codewords estn tan separados que la probabilidad de que los errores conviertan al codeword deseado en otro codeword es muy pequea. Segn esto, la deteccin de errores se limita a responder a la pregunta : "Es el mensaje recibido un codeword o no ?" Si es un codeword, uno supone que no hay errores, de esta manera la probabilidad de no detectar un error es la probabilidad de que los posibles errores conviertan un codeword en otro. Cuando se detecta un error existen dos mtodos para corregirlo : 1.- El receptor rechaza el mensaje recibido y solicita al transmisor que retransmita el mensaje. 2.- El receptor corrige el error al encontrar el codeword vlido ms prximo al mensaje recibido. Este procedimiento se llama forward error correction (FEC).

2.-Distancia Hamming y distancia de cdigo.


Sean los mensajes secuencias binarias de n bits, esto hace que los mensajes o vectores de n bits formen un conjunto de 2n posibles. La distancia Hamming o distancia entre dos vectores es el nmero de posiciones de bits en los cuales dichos vectores toman valores diferentes. Por ejemplo, sean 2 vectores de 4 bits : c1 = 0 1 0 1 y c2 = 1 1 0 0 la distancia entre c1 y c2 es 2. Supongamos que de entre los 2n posibles vectores elegimos un subgrupo que constituyen nuestro cdigo. Pues la distancia del cdigo ser la mnima distancia Hamming entre todas las posibles combinaciones de codewords. Se demuestra que si la distancia de un cdigo es

d, entonces podemos detectar y corregir los errores que afecten a t bits de cada codeword, siendo : As si la distancia de un cdigo es 5 entonces podemos detectar y corregir errores en 2 bits.

3.- Cdigos lineales.


Sea nuestro cdigo formado por M codewords de los 2n posibles. Un cdigo ser lineal si dados dos codewords c1 y c2 cualesquiera de los M posibles, entonces c = 1 c1 + 2 c2 es un codeword, donde 1 y 2 pueden tomar valores 0 1 verificndose las siguientes operaciones : 0+0=0 0+1=1+0=1 1+1=1 1* 1=1 0*0=0 1*0=0*1=0 Adems, el vector formado por todos sus comoponentes 0 debe formar parte del cdigo.Veamos un ejemplo : Tomemos vectores de 8 bits y formrmos un cdigo con 4 codewords que sea lineal : (0 0 0 0 0 0 0 0) (0 1 1 1 1 1 1 0 0) (1 0 0 1 1 1 1 1) (1 1 1 0 0 0 1 1) Se puede verificar que la combinacin lineal de dos de ellos da otro : 1*(1 0 0 1 1 1 1 1) + 1*(1 1 1 0 0 0 1 1) = (0 1 1 1 1 1 1 0 0) al cdigo. Otra de las condiciones que cumple un cdigo lineal es que : Luego esto hace pensar que realmente slo hacen falta k bits para obtener M vectores distintos pero se forman vectores con n bits para introducir la redundancia controlada de la que se habla en el apartado 1. As que de los n bits, se puede decir que k pertenecen al mensaje que realmente queremos enviar y n-k bits forman los dgitos de comprobacin. Un cdigo as se llama cdigo (n,k). Todos los codewords se pueden obtener a partir de una matriz generatriz G generatriz : c=m*G donde c es el codeword de n bits del cdigo (n,k), m es el mensaje que realmente nos interesa transmitir de los M posibles y como M = 2k implica que m se puede codificar con k bits (matriz 1xk) y G es una matriz con k filas y n columnas que transforma (codifica) nuestro mensaje m de k bits en un codeword de longitud n que ser transmitido o almacenado. Como G es un matriz ( k x n ) con k vectores linealmente independientes, aplicamos las reglas del lgebra y la escribimos de la forma G = ( I, P ) donde I es la matriz identidad de (k x k) y P la matriz paridad de (k x (n-k)).

entonces :

c = ( m1 m2 ..........mk ) * G = ( m1 m2 ..........mk qk+1 qk+2 .............qn ) Luego se evidencia que el codeword est formado po k bits de nuestro mensaje y n-k bits para el testeo. Sea una matriz generadora : donde se observa que I es de 2 x 2 luego k=2 y n=8, con esto M=2k=22=4 codewords que forman el cdigo. Para obtenerlo probamos con todas las combinaciones posibles : m =( 0 0 ) => c0 =( 0 0 0 0 0 0 0 0 ) m =( 0 1 ) => c1=( 0 1 1 1 1 1 0 0 ) m =( 1 0 ) => c2 =( 1 0 0 1 1 1 1 1 ) m =( 1 1 ) => c0 =( 1 1 1 0 0 0 1 1 ) Se puede observar que la distancia de este cdigo es d=5 y por tanto d=2*t+1 => t=2, luego se pueden detectar y corregir 2 bits errneos. Veamos cmo se detectan y corrigen estos errores. Para ello obtenemos la matriz nula de la siguiente manera : Si G = ( Ik, P ) entonces H = ( PT , In-k ) de forma que si P es de ( k x (n-k) ) Ik de ( k x k ), entonces PT es de ( (n-k) x k ) obligando a In-k a ser de ( (n-k) x (n-k) ) y por tanto H es de ( (n-k) x n ).Pues bien se puede comprobar que G * HT = 0 ( k x (n-k) ). Veamos un ejemplo : Sea

Se observa que

por tanto Ahora calculamos

Llamemos sndrome del codeword c a : s = c * HT pero teniendo en cuenta que c = m * G entonces :

s = m * G * HT pero como G * HT = 0 entonces : s=m*0=0 luego se observa que el sndrome de un codeword es nulo. Imaginemos ahora que el vector transmitido es el codeword c y el recibido es c ms un error e, osea r = c + e, calculemos el sndrome de r : s = r * HT = ( c + e ) * HT = c * HT + e * HT = e * HT 0 Luego, cuando el sndrome de un vector recibido no es nulo, entonces, hemos detectado un error. Una vez detectado, la correccin se obtiene haciendo : c=r+e como sabemos que podemos corregir t bits errneos del codeword como mximo, conocemos el tipo de errores que podemos corregir y los sndromes que daran a priori por lo que podemos identificar un sndrome con un error. El sndrome lo obtenemos de s = r * HT miramos en una tabla a qu error corresponde y corregimos el vector mediante c = r + e. Veamos todo con un ejemplo. Sea la matriz generadora de donde podemos obtener k=2, n=5 y M=4, dichos vectores son : c0 = ( 0 0 0 0 0 ) c1 = ( 1 0 1 1 0 ) c2 = ( 0 1 0 1 1 ) c3 = ( 1 1 1 0 1 ) Tambin podemos obtener H :

La distancia del cdigo es d=3=2*t+1 => t=1 luego seremos capaces de detectar errores de 1 bit. Por ejemplo en el primer bit por la izquierda : c0 codeword recibido 00000 10000 c1 10110 00110 c2 01011 11011 c3 11101 01101 sndrome 000 110

donde e = ( 1 0 0 0 0 )

los dems posibles errores de un bit y sus sndromes se pueden ver el la siguiente tabla :

c0 codeword recibido recibido recibido recibido 00000 01000 00100 00010 00001

c1 10110 11110 10010 10100 10111

c2 01011 00011 01111 01001 01010

c3 11101 10101 11001 11111 11100

sndrome 000 011 100 010 001

Observamos que si el error se ha cometido en un bit, el sndrome identifica unvocamente el error cometido. Por ejemplo imaginemos que hemos recibido el vector r = ( 0 1 0 0 1 )

Vamos a la tabla y vemos que el sndrome calculado se corresponde con error en el segundo bit por la derecha, osea, e = ( 0 0 0 1 0 ) luego el codeword recuperado ser : c=e+r=(01011)

4.- Una serie de reglas :


Un cdigo binario natural de 3 bits asigna los siguientes pesos decimales ( 22 21 20 ) = ( 22 2 1 ) as el vector ( 1 0 1 ) se representa como 22+1, ( 1 1 0 ) como 22+2, pues bien, si en vez de emplear como base el 2 empleamos , entonces los pesos sern ( 2 1 ) as ( 1 0 1 ) se representa por 2+1, ( 1 1 0 ) ser 2+ , as que podemos representar cualquier secuencia de tres bits con ( 2 1 ). Por otro lado, en un campo finito o de Galois (GF) se definen las siguientes operaciones : (elemento del campo) + (el mismo elemento) = 0 lo que significa que si 3 es un elemento del campo, entonces 3+ 3 = 0 => 3 = - 3 por lo que en las operaciones con elementos del campo finito, las operaciones que impliquen un cambio de signo las obviamos sustituyndolas por los mismos operandos con signos positivos. Si en dicho campo se definen y un polinomio p(x) donde es la raz de p(x), se pueden obtener valores de i con dicho polinomio aplicando las reglas anteriores, por ejemplo sea : p(x) = x2 + x + 1 y una raz suya, entonces :

p( )= - multiplicamos por :
2

+ +1=0
2

= +1

multiplicamos por : multiplicamos por : y a partir de aqu se repite :


6 5 4

= =

= +1 = +1
2

Si un polinomio tiene por races por ejemplo 1, ,

ste ser :
2

p(x) = ( x+1 ) ( x+ ) ( x+

5.- Cdigos Reed-Solomon :


Este tipo de cdigos emplea algo de todo lo visto hasta ahora para llevar a cabo la deteccin y correccin de errores. Sus elementos forman parte de un campo finito donde rigen reglas como las vistas en el apartado 4. Parten de una raz , un polinomio y un campo finito de dimensin q=2m, osea GF(q)= GF(2m), en este caso codificamos los bits segn los pesos ( m-1 m-2 ............ 1). Veamos cmo se codifican y decodifican cdigos Reed-Solomon con un ejemplo. Supongamos un campo finito de 8 elementos, osea GF(23) luego los pesos sern ( 2 1 ) una tripleta de este tipo se considera un smbolo para distinguirlo de un bit. Por tanto, en nuestro ejemplo un smbolo es de 3 bits, as que si tenemos los siguientes smbolos ( 1 0 2 ) realmente tendramos la siguiente secuencia de bits ( 010 001 000 100 ) por tanto 4 smbolos de nuestro ejemplo suponen 4x3=12 bits. Pues bien, los cdigos Reed-Solomon detectan smbolos errneos y corrigen smbolos, lo que significa que en nuestro caso, si somos capaces de corregir dos smbolos, seremos capaces de corregir 6 bits errneos, pero no nos confundamos, no 6 bits cualesquiera, tendran que pertenecer a dos smbolos ya que podra darse el caso de 6 bits errneos pero cada uno en un smbolo lo que supondra corregir 6 smbolos. Para la secuencia de 4 smbolos anterior, dos smbolos errneos podran ser ( 001 001 000 010 ) donde el primer smbolo a pasado de a 1 y el ltimo de 2 a , se observa que han cambiado 4 bits pero en 2 smbolos, as que lo mejor para no confundirnos ser saber que somos capaces de corregir smbolos y no bits. En los cdigos Reed-Solomon la distancia de cdigo viene dada por la frmula d=m+1=nk+1 donde m es el grado de un polinomio generador g(x), k viene dada por el exponente de la base 2 en las dimensiones del campo de Galois, osea GF(2k). As que si nos dicen que g(x) tiene grado m=4 y los elementos del cdigo se toman de un campo finito GF(23) entonces k=3 y como m=n-k, obtenemos n=7, por tanto el cdigo ser (7,3). Que significa que empleamos 7 smbolos y 3 son para el mensaje que queremos transmitir o almacenar. Para obtener con cuantos bits codificamos cada smbolo empleamos otro polinomio y una raz de l.

Con el polinomio generatriz g(x) se puede obtener la matriz generatriz G, veamos cmo con un ejemplo. Sea g(x)= x4+x3+x2+1 supongamos un cdigo (7,3), pues las filas de G vienen dadas por la frmula : fila( j ) = xn-j + rn-j (x) 1<= j <= k donde rj (x) es el resto de dividir xj entre g(x). Para nuestro ejemplo :

As que fila( 1 )=x6+x3+x2+x que se traduce en : x6 fila (1 ) =( 1 x5 0 x4 0 x3 1 x2 1 x1 1 x0 0 )

fila( 2 ) = x5 + r5 (x)

As que fila( 2 )=x5+x2+x+1 que se traduce en : fila ( 2 )= ( 0 1 0 0 1 1 1 ) fila( 3 ) = x4 + r4 (x)

As que fila( 3 )=x4+x3+x2+1 que se traduce en : fila ( 3 )= ( 0 0 1 1 1 0 1 ) Luego G queda :

Siendo

luego podemos obtener H

En el caso de cdigos Reed-Solomon el polinomio generatriz g(x) es del tipo : Sean las races del polinomio generatriz g(x) 1, , 2, 3 ,definidos sus coeficientes en un campo finito GF(23) por lo que k=3 y sea el polinomio que define la base x3+x+1 cuya raz primitiva es . Veamos qu tipo de cdigo define esto y como se codifica, detecta y corrige errores : El polinomio x3+x+1 tiene por raz por lo que 3+ +1=0 de aqu obtenemos que la base llegar como mximo hasta 2 ya que 3 se puede poner en funcin de elementos de menor grado porque - 3= 3= +1, luego obtenemos que los pesos son ( 2 1) que nos indica que codificamos los smbolos con tres bits. 3= +1 multiplicamos por : 4= 2+ multiplicamos por y operamos : 5= 3+ 2= 2+ +1 multiplicamos por y operamos : 6= 3+ 2+ = +1+ 2+ = 2+1

multiplicamos por : 7= 3+ = +1+ =1 multiplicamos por : 8= multiplicamos por : 9= multiplicamos por : y as sucesivamente.
10 2

= 3= +1

Obtengamos ahora g(x) : +1=


3

; 3+ 2= +1+ 2=

g(x)=(x2+ 3x+ ) (x2+ 5x+ 5) = x4+ 5x3+ 5x2+ 3x3+ 8x2+ 8x+ x2+ 6 x+ 6 g(x)=x4+( 5+ 3)x3+( 5+ 8+ )x2+( 8+ 6)x+ 5+ 3= 2+ +1+ +1= 5+ 8+ = 5+ + = 8+ 6= + 2+1=
5 5 2 6

g(x)=x4+ 2x3+ 5x2+ 5x+

bueno ya tenemos nuestro polinomio generatriz de grado m=4 por tanto m=n-k => n=7 y la distancia del cdigo ser d=m+1=4+1=5.Se trata de un cdigo (7,3) pero ahora son smbolos y no bits, esto es, cada codeword es de 7 smbolos, de los cuales 3 smbolos son el mensaje que interesa codificar, cada smbolo es de 3 bits segn se obtiene de los pesos ( 2 1) por tanto, cada codeword consta de 7x3=21 bits.

Anda mungkin juga menyukai