TeoriadelaInformacionylaCodificacion

INSTITUTO DE INVESTIGACIONES EN INFORMÁTICA CARRERA DE INFORMÁTICA

FACULTAD DE CIENCIAS PURAS Y NATURALES UNIVERSIDAD MAYOR DE SAN ANDRÉS

TEORÍA DE LA INFORMACIÓN Y LA CODIFICACIÓN

Por Lucio Torrico

A Avril.

2

TABLA DE CONTENIDO PREFACIO.......................................................................................................................... 5 CAPÍTULO 1: FUENTES DE INFORMACIÓN Y ENTROPÍA FUENTES DE INFORMACIÓN DE MEMORIA NULA................................................. 6 FUENTES DE INFORMACIÓN DE MEMORIA NULA EXTENDIDAS....................... 9 FUENTES DE MARKOV..................................................................................................10 ENTROPÍA DE UNA FUENTE DE MARKOV............................................................... 12 FUENTE AFÍN O ADJUNTA........................................................................................... 18 EXTENSIÓN n-ésima DE UNA FUENTE DE MARKOV.............................................. 19 CAPÍTULO 2: INTRODUCCIÓN A LOS CÓDIGOS CÓDIGOS.......................................................................................................................... 22 EXTENSIÓN DE ORDEN n DE UN CÓDIGO.............................................................. 28 PROPIEDADES DE LOS CÓDIGOS............................................................................... 29 TEOREMA DE KRAFT.................................................................................................... 31 TEOREMA DE McMILLAN............................................................................................ 41 CAPÍTULO 3: CÓDIGOS Y FUENTES DE INFORMACIÓN. PROPIEDADES LEMA DE GIBBS................................................. ............................................................ 48 PROPIEDADES DE LA ENTROPÍA................................................................................ 49 ENTROPIÁ DE LA EXTENSIÓN DE UNA FUENTE.................................................... 50 LONGITUD MEDIA DE UN CÓDIGO Y CÓDIGO COMPACTO................................ 54 OTRAS PROPIEDADES DE LOS CÓDIGOS INSTANTÁNEOS COMPACTOS........ 55 RELACIONES ENTRE ENTROPÍA Y LONGITUD MEDIA......................................... 58 EL PRIMER TEOREMA DE SHANNON........................................................................ 61 CAPÍTULO 4: CODIFICACIÓN DE FUENTES Y CONSTRUCCIÓN DE CÓDIGOS CONSTRUCCIÓN DE UN CÓDIGO PARA UNA FUENTE-S...................................... 62 CODIFICACIÓN ARITMÉTICA...................................................................................... 68 CAPÍTULO 5: CANALES CANALES DE INFORMACIÓN CON RUIDO............................................................... 71 LA INFORMACIÓN MUTUA NO ES NEGATIVA........................................................ 75 RECIPROCIDAD DE LA INFORMACIÓN MUTUA..................................................... 78 OTROS RESULTADOS................................................. .................................................. 80 CANALES ESPECIALES................................................. ............................................... 83 CANALES EN SERIE................................................. ..................................................... 88 TEOREMA DEL PROCESAMIENTO DE DATOS......................................................... 89 ADITIVIDAD DE LA INFORMACIÓN MUTUA........................................................... 93 REDUCCIÓN DE CANALES................................................. ......................................... 97 CAPACIDAD DE UN CANAL....................................................................................... 100 CAPÍTULO 6: CÓDIGOS CANAL REGLAS DE DECISIÓN.................................................................................................103 EL SEGUNDO TEOREMA DE SHANNON................................................................. 107 DISTANCIA DE HAMMING........................................................................................ 111 CÓDIGOS DETECTORES Y CORRECTORES............................................................ 115 ALGUNOS EJEMPLOS DE CÓDIGOS CANAL.......................................................... 124

3

CAPÍTULO 7: CÓDIGOS LINEALES....................................................................... 130 MATRIZ GENERADORA.............................................................................................. 131 CÓDIGO DUAL.............................................................................................................. 134 MATRIZ DE TESTEO DE PARIDAD........................................................................... 135 SÍNDROME................................................................................….........……………… 140 CÓDIGO EXPANDIDO.................................................................................................. 141 MATRIZ ESTÁNDAR.................................................................................................... 142 CÓDIGOS DE HAMMING............................................................................................. 147 CAPÍTULO 8: CÓDIGOS CÍCLICOS........................................................................ 154 IDEALES Y CÓDIGOS CÍCLICOS. ............................................................................. 155 ANEXO 1 (Demostración de " lim pi · logr (1/pi ) = 0" ).............................................. 172

pi  0

ANEXO 2 (Demostración de "Si x>0 Kx  x·l

Entonces K  1")........................ 173

ANEXO 3 (Campos y Espacios lineales)........................................................................ 174 ANEXO 4 (Anillo de polinomios e ideales).................................................................... 183 Índice................................................................................................................................ 185

BIBLIOGRAFÍA

4

PREFACIO Este trabajo tiene la pretensión de presentar la Teoría de la Información y la Codificación desde una perspectiva académica; tratando de reflejar su elegancia y su riqueza inherente. Como es imaginable, no se ha podido abarcar todo el espectro posible, hubo la necesidad de tomar posiciones y hacer elecciones. A la descripción esquemática y ejemplificada se la ha complementado con un cierto rigor en la demostración, que sin embargo quiere poseer claridad a través de explicaciones y un mayor número de pasos intermedios. Se cubren los canales sin ruido, de Markov, con ruido, sistema de entropías y codificación libre de errores; además se ha introducido una parte dedicada a los códigos detectores y correctores y a su teoría subyacente, en particular los códigos lineales. Resta agradecer a la Universidad Mayor de San Andrés, a la Facultad de Ciencias Puras y Naturales, a la Carrera de Informática y al I.I.I., es decir, a las personas de estas instituciones quienes han hecho que este esfuerzo sea posible; asimismo a tod@s quienes han trabajado y trabajan en el campo, sin cuya labor previa nada de esto existiría. En particular gracias a Ivone Neolopan, Marcio Gutierrez, Roxana Lopez y Nelson Pacheco. Los desaciertos son mi responsabilidad: me adelanto en agradecer a quienes hagan notarlos, tanto en los errores “de transcripción” –valga el eufemismo-, como en los otros que merecerán doble disculpa y doble agradecimiento.

Lucio Torrico [email protected]

5

FUENTES DE INFORMACIÓN DE MEMORIA NULA Una fuente de información de memoria nula, denotada por Fuente-S, es un par ordenado definido como sigue. Fuente-S = (S,Ω) donde: S = {s1, s2, ... , sq} es el alfabeto de la fuente Ω es una distribución de probabilidades que asigna a cada símbolo si (i=1,...,q) una probabilidad de emisión prob(si) = pi De la definición de distribución de probabilidades está claro que: i) 0≤ pi ≤1 (i=1,...,q) q

ii)  pi = 1 i 1

Usualmente se representa en una tabla así:

S s1

pi p1

.

.

. .

. .

sq

pq

Ejemplo concreto de una Fuente-S: S

pi

s1 s2 s3 s4

0.2 0.1 0.35 0.35

Con q = 4

Nótese que utilizamos "q" para el número de símbolos de la fuente. Fuente equiprobable.- Una Fuente-S de memoria nula se dice equiprobable cuando todas sus probabilidades son iguales, es decir, cuando p1 = ... = pq = 1/q Ejemplo: con q = 2 S

pi

s1 s2

1/2 1/2

En una Fuente-S de memoria nula la aparición/emisión de un símbolo es independiente de la emisión de otro. Es común utilizar “S” en vez de “Fuente-S”. Cantidad de información que conlleva el símbolo si denotada por I(si).Debe medir el grado de incertidumbre como una función decreciente de la probabilidad: a menor incertidumbre menor información, a mayor incertidumbre mayor información; o de manera equivalente, a mayor certidumbre menor información y a menor certidumbre mayor información.

6

Debe sumarse la informacion de dos símbolos sucesivos independientes, es decir: I(sisj) = I(si) + I(sj) Aunque hubieron algunas propuestas más, se ha aceptado la siguiente definición: I(si) = logr 1/pi = - logr pi r-its Por r-its entenderemos las unidades de la cantidad de información, según sea la base r del logaritmo que se utilice. Cuando la base es r = 2 las unidades se llaman bits, con r = 10 decs, con r = e nats, etc. Es claro que Por convención

cuando pi = 1, I(si) = logr 1/1 = logr 1 = 0 cuando pi = 0, I(si) = logr 1/0 = - logr 0 = +∞

r-its r-its

Entropía de una fuente de información de memoria nula, denotada por Hr(S).- Está definida por: q

q

i 1

i 1

Hr(S) =  pi · I(si) =  pi · logr 1/pi = -

q



i 1

pi · logr pi

r-its

Y mide la cantidad de información media por símbolo de una Fuente-S de memoria nula. Sus unidades son medidas en r-its. Cuando la base del logaritmo es r = 2 las unidades se llaman bits, con r = 10 decs, con r = e nats, etc. Generalmente se trabaja con r = 2 -es decir la entropía medida en bits- y suele omitirse la escritura de este símbolo. Es claro que cuando pi = 1, pi · logr (1/pi ) = 1 · log 1/1 = 1 · 0 = 0 r-its Estableceremos que cuando pi = 0, pi · logr (1/pi ) = 0 r-its (Ver Anexo 1) Ejemplo: Calcularemos la entropía en nats para la Fuente-S: 4

S

pi

s1 s2 s3 s4

0.2 0.1 0.35 0.35 =

He(S) =  pi · loge 1/pi i 1

= 0.2 · ln(1/0.2) + 0.1 · ln(1/0.1) + 0.35 · ln(1/0.35) + 0.35 · ln(1/0.35) = 2/10 · ln (10/2) + 1/10 · ln (10/1) + 35/100 · ln(100/35) + 35/100 · ln(100/35) = 0.2 · 1.60943 + 0.1 · 2.30258 + 0.35 · 1.04982 + 0.35 · 1.04982 0.32188 + 0.23025 + 0.36743 + 0.36743 = 1.28702 nats

7

Es interesante notar que si tenemos la entropía en v-its (base v), puede calcularse fácilmente la entropía en r-its (base r) así: Dado que logv z = (logr z / logr v), entonces: q

q

Hv(S) =∑ pi · logv 1/pi v-its = (1/ logr v) · ∑ pi · logr 1/pi i=1

r-its

i=1

Es decir,

Hv(S) v-its = (1/ logr v) Hr(S) r-its Pero entonces Hr(S) r-its = logr v · ( Hv(S) v-its )

Obviamente también es válido Hr(S) r-its = ( 1/logv r ) · ( Hv(S) v-its )

Para nuestro ejemplo donde He(S) = 1.28702157893 nats, si queremos calcular la entropía en bits tendremos: H2(S) = log2 e · 1.28702157893 bits = (1,44269504088)·(1.28702157893) bits = 1,85677964944 bits = (1/ln 2) · ( 1.28702157893) bits = (1.44269504088) · ( 1.28702157893) bits = 1,85677964944 bits

8

FUENTES DE INFORMACIÓN DE MEMORIA NULA EXTENDIDAS La extensión de orden n de una fuente de información de memoria nula, denotada por Fuente-Sn, es otra fuente de memoria nula que se obtiene de la Fuente-S original según se indica a continuación. Sea la Fuente-S original representada así:

S s1

pi p1

. . .

. . .

sq

pq

La Fuente-Sn (extensión de orden n de la Fuente-S) tiene como su alfabeto Sn = {1, 2, ... , qn}, es decir, qn símbolos.

Cada j = sj1 sj2 ... sjn con sji  S, es decir, los símbolos de la fuente extendida son secuencias de n-símbolos de la fuente original. Además la prob(j) = prob(sj1 sj2 ... sjn) = prob(sj1) · ... · prob(sjn) = pj1· ... · pjn Ejemplo: Para la siguiente Fuente-S de memoria nula original:

pi

S

s1 p1 = 0.2 s2 p2 = 0.8 Su extensión de orden n=2 es la siguiente Fuente-S2 también de memoria nula: S2

1 = s1s1 2 = s1s2 3 = s2s1 4 = s2s2

pj p1· p1 = 0.04 p1· p2 = 0.16 p2 · p1 = 0.16 p2 · p2 = 0.64

En el caso de estas fuentes extendidas indicaremos -sin demostración- que las probabilidades asignadas según se indicó, están entre 0 y 1, y su sumatoria es igual a la unidad. Obviamente siendo una fuente extendida una fuente de memoria nula, puede hallarse su entropía.

9

FUENTES DE MARKOV Una fuente de Markov de orden m es una fuente con memoria que toma en cuenta ('recuerda') los m símbolos anteriores al símbolo que está por emitirse. La probabilidad de aparición del símbolo que está por emitirse depende de cuáles son los m símbolos anteriores. Denotada por Fuente-M se define así: Fuente-M=(S,m,P,W(0)) donde: S = {s1, s2, ... , sq} es el alfabeto de la fuente. m es el orden de la fuente (en función de cuántos símbolos anteriores está la probabilidad del siguiente símbolo a emitirse). P es un conjunto de probabilidades del tipo p(si / sj1 sj2 ... sj m) que asigna a cada símbolo si (i=1,...,q) una probabilidad de emisión en función de m símbolos anteriores. Diremos que estos m símbolos "sj1 sj2 ... sjm" conforman el j-ésimo estado de la fuente. Es claro que hay qm estados. La probabilidad p(si / sj1 sj2 ... sjm) es la probabilidad de pasar del estado "sj1 sj2 ... sjm" al estado "sj2 sj3 ... sjm si". Por ello, en vez de describir el conjunto P como un listado, es usual presentarlo como una matriz de transiciones entre estados de dimensión qm X qm. A los estados de la fuente de Markov los llamaremos α1, ··· , αqm. W(0) es la distribución inicial de probabilidades de los estados de la Fuente-M. W(0) = [ w1(0), ··· , wqm(0) ]T (la T significa transpuesta), donde wi(0) denota la probabilidad de estar en el estado αi al iniciar la fuente la emisión de sus símbolos, es decir, en el tiempo 0: el supercero significa precisamente dicho instante cero (wi(0) es pues la probabilidad de que los primeros m símbolos emitidos por la fuente sean los denotados por αi). Es claro que w1(0) + ... + wqm(0) = 1. Ejemplo: Sea la siguiente fuente de Markov de orden 2. S={0,1} q=2 m=2 P: p(0)=0.2 p(100) = 0.8 p(0)=0.4 p(101) = 0.6 p(0) =0 p(110) = 1 p(0) =0.5 p(111) = 0.5 Los qm=4 estados son α1=00, α2=01, α3=10 y α4=11. Visto así, también puede presentarse P de la siguiente manera (donde Pij es la probabilidad de pasar del estado j al estado i):

P=

00 01 10 11

00 0.2 0.8 0 0

01 0 0 0.4 0.6

10 0 1 0 0

11 0 0 0.5 0.5

Nótese que las columnas deben sumar 1.

No es común etiquetar los nombres de los estados, de manera que es más frecuente ver P así:

P=

0.2 0.8 0 0

0 0 0.4 0.6

0 1 0 0

0 0 0.5 0.5

W(0) = [ w1(0), w2(0), w3(0), w4(0) ]T = [1/4, 1/4, 1/4, 1/4]T

10

Las transiciones entre estados permiten representar las fuentes de Markov mediante un grafo (cada estado es un nodo y arcos entre estados etiquetados con las probabilidades de transición, los arcos con probabilidad igual a cero no se grafican); en el caso del ejemplo el grafo se ve así:

En el estado α1=00 el arco tiene la etiqueta "0/0.2" que significa: 0.2 es la probabilidad de emisión de un 0 dado que los 2 símbolos anteriores fueron 00, que es lo mismo que la probabilidad de pasar del estado α1=00 al estado α1=00. En vez de esta etiqueta "0/0.2", es más frecuente colocar sólo la etiqueta "0.2". Lo mismo sucede con todos los demás arcos. (Nótese que la suma de las probabilidades de los arcos que salen de un nodo suman 1, por ejemplo del nodo "11" sale un arco con probabilidad 0.5 y otro arco también con probabilidad 0.5, la suma de las probabilidades de ambos arcos es 1).

11

ENTROPÍA DE UNA FUENTE DE MARKOV El cálculo de la entropía de una fuente de Markov es semejante al cálculo de la entropía en una fuente de memoria nula. Requiere sin embargo algunos conceptos adicionales y cálculos previos. En principio se define la entropía de la Fuente-M en el estado

"sj1sj2 ... sjm" como:

q

Hr(S / sj1sj2 ... sjm) = -  p(si / sj1sj2 ... sjm) · logr p(si / sj1sj2 ... sjm) i 1

r-its

Ejemplo tomado del libro de Abramson: Sea la siguiente Fuente-M

Donde el orden es m=2, S={0,1}, q=2 Los qm=4 estados son α1=00, α2=01, α3=10 y α4=11. P: p(0)=0.8 p(100) = 0.2 p(0)=0.5 p(101) = 0.5 p(0) =0.5 p(110) = 0.5 p(0) =0.2 p(111) = 0.8 Y en forma de matriz:

P=

0.8 0.2 0 0

0 0 0.5 0.5

0.5 0.5 0 0

0 0 0.2 0.8

W(0) = [ w1(0), w2(0), w3(0), w4(0) ]T = [0, 0, 0, 1]T Calcularemos -en bits- la entropía de la Fuente-M en el estado α1=s1s2=00 2

H2(S/α1)=H2(S/00)= -  p(si/00)·log2 p(si/00) = i 1

= -[p(0/00)·log2 p(0/00) + p(1/00)·log2 p(1/00)] = -[0.8·log2 0.8 + 0.2·log2 0.2] = -[(0.8)·(-0.32192) + (0.2)·(-2.32192)] = -[-0.257536 + -0.464384 ] = 0.7219 bits

12

El resto de las entropías por estado son: H2(S/α1) = H2(S/00) = 0.72192 H2(S/α2) = H2(S/01) = 1 H2(S/α3) = H2(S/10) = 1 H2(S/α4) = H2(S/11) = 0.72192

bits bits bits bits

Distribución estacionaria.- Recordemos que W(0) = [ w1(0), ... , wqm(0) ]T es la distribución inicial (de probabilidades de los estados). Llamaremos distribución estacionaria al vector columna W=[w1, ... , wqm]T que es solución del sistema: P·W=W junto a w1+ ... + wqm = 1. (wi está asociado a αi, haremos una ampliación más adelante después del ejemplo). La entropía de una Fuente-M se define así: qm

Hr (M) =∑

wj · Hr (S / sj1 sj2 ... sjm)

r-its

j=1

Ejemplo: Con la Fuente-M de arriba, el sistema de ecuaciones P·W=W es:

0.8 0 0.5 0   w1   w1  0.2 0 0.5 0   w2      ·   =  w2   0 0.5 0 0.2  w3   w3         0 0.5 0 0.8  w4   w4 

junto a w1 + w2 + w3 + w4 = 1

Es decir, 0.8 w1 0.2 w1 0.5 w2 0.5 w2

+ + + +

0.5 w3 0.5 w3 0.2 w4 0.8 w4

= = = =

w1 w2 w3 w4

junto a w1 + w2 + w3 + w4 = 1

Este sistema de ecuaciones puede resolverse de varios modos (por ejemplo en MATLAB). Si se elige resolverlo manualmente puede aportar claridad utilizar fracciones en vez de decimales, por ej. en vez de 0.8 utilizar 8/10. La solución en nuestro caso es: w1 = 5/14 = 0.35714, w2 = 2/14 = 0.14285, w3 = 2/14 = 0.14285, w4 = 5/14 = 0.35714 Recordemos que: H2(S/α1) = H2(S/00) = 0.72192 H2(S/α2) = H2(S/01) = 1 H2(S/α3) = H2(S/10) = 1 H2(S/α4) = H2(S/11) = 0.72192

bits bits bits bits

Finalmente H2(M) = 0.80137 bits

13

Distribución límite.- La distribución inicial de estados W(0) sólo nos indica la probabilidad de que la fuente empiece la emisión de símbolos en un estado αi o en otro, en el tiempo 0. De hecho, no siempre se ofrece W(0) o bien puede trabajarse con un vector de referencia donde todos sus valores son ceros excepto uno igual a la unidad, por ejemplo: W(0) = [ w1(0), ... , wqm(0) ]T = [1, 0, ... , 0]T. Puede generalizarse esta idea a W(t) = [w1(t), ··· , wqm(t)] que denota la probabilidad de que la fuente esté (otros dicen empiece) en el estado α1, ... ,αqm respectivamente, en el tiempo t. Una idea asociada es calcular la probabilidad de ir del estado αi al estado αj en t pasos, si lo hacemos para todos los estados tendremos lo que se denomina distribución de probabilidades del sistema para dicho tiempo t, o como otros llaman la matriz de transición de t pasos denotada por P(t). Desde un punto de vista formal este cálculo requiere utilizar la ecuación de Chapman-Kolmogorov, pero ellos muestran que finalmente esto puede calcularse con matrices así: P(t) = Pt W(1) = P·W(0), W(2) = P·W(1), W(3) = P·W(2), etc. En general: W(t+1) = P·W(t) Haciendo los reemplazos que sugiere la inducción tenemos que: W(t+1) = P(t+1) · W(0) = Pt+1 · W(0) Como todas estas matrices y vectores representan distribuciones de probabilidad, para cada t la suma de sus columnas debe ser 1. Denotaremos por P(∞) a la matriz límite de la Fuente-M, donde P(∞) = lim P(t) . Llamaremos distribución límite a cualquier columna de P(∞).

t  

Las condiciones bajo las cuales este límite existe y su cálculo están fuera del alcance de este texto (por ejemplo el uso de la transformada Z puede ser útil para su estudio). Un resultado conocido es que la Fuente-M tiene una distribución límite cuando  t>0 tal que Pt tenga todos sus valores positivos. En este caso P(∞) converge y sus columnas son iguales: se obtiene la distribución límite calculando Pt para un t suficientemente grande y tomando cualquier columna.

Recordemos que se llama distribución estacionaria a la solución del sistema P·W=W junto a w1+ ··· + wqm = 1. W=[w1, ··· , wqm]T, donde wi es la probabilidad estable de aparición en el tiempo del estado αi. Esta solución no es necesariamente única. Cuando la Fuente-M es regular su distribución límite existe y coincide con la distribución estacionaria que es única (teorema de Perron-Frobenius). Precisamente esta es una manera iterativa de calcular la distribución estacionaria: calcular Pt -para t‟s suficientemente grandes- hasta ver que converjan, esto es Pj=Pj+1=Pj+2=..., etc. (sólo funciona cuando la Fuente-M es regular, véase la siguiente página). Puede ser que no exista la distribución límite pero sí la distribución estacionaria (única o no).

14

Fuente regular y ergódica.Podemos trabajar la Fuente-M como una cadena de Markov. Cuando centramos los conceptos considerando el grafo de la Fuente-M, hay un modo de determinar la ergodicidad o no ergodicidad. No abundaremos en formalismos y simplificaremos la presentación. Una Fuente-M es ergódica cuando es irreducible: hay un camino de un estado a otro estado, para cualquier par de estados. Una Fuente-M es regular cuando  t>0 tal que Pt tenga todos sus valores positivos. Una fuente-M es regular cuando se cumplen las tres siguientes condiciones: 1) Es irreducible: hay una sola clase cerrada. Es decir, hay un camino de un estado a otro estado, para cualquier par de estados. Es decir, cuando es ergódica. 2) Es recurrente (positiva): hay un camino de un estado al mismo estado, para cada estado (cuando hay un número finito de estados la parte 'positiva' siempre se cumple). 3) Es aperiódica: no hay un único número fijo de pasos (o múltiplo de él) para ir de un estado al mismo estado. Es decir, una Fuente-M regular es ergódica, pero existen Fuentes-M ergódicas que no son regulares. Cuando hay más de una distribución estacionaria podemos asumir que la Fuente-M no es ergódica.

Ejemplos: Se sugiere utilizar MATLAB (junto a los conceptos) para verificar los comentarios.

1 0 0.5 0 0 0 0.5 0  P=  0 0.5 0 0   0 0.5 0 1

No es irreducible: no podemos ir de α1 a α3 por ejemplo. Luego, no es ergódica. Si calculamos P500,P501, etc. Veremos (con 'format long g' en MATLAB) diferencias entre una y otra matriz. No tiene distribución límite. Además hay por lo menos estas dos distribuciones estacionarias: w1=1, w2=0, w3=0, w4=0 o bien w1=0, w2=0, w3=0, w4=1

15

0.8 0 0.2 0 P=   0 0.6   0 0.4

0 0  0 0.5  0 0.5

0 1

No es irreducible: no podemos ir de α4 a α1 por ejemplo. Luego, no es ergódica. Si calculamos P2001,P2002, etc. Veremos (con 'format long g' en MATLAB) diferencias entre una y otra matriz. No tiene distribución límite. Es además aperiódica. Tiene una única distribución estacionaria: w1=0, w2=5/14, w3=5/14, w4=4/14 Sucede lo mismo con

0 0 1 0 P=  0 0.6  0 0.4

0 0  0 0.5  0 0.5

0 1

Nuestro próximo ejemplo es:

0 0 1  P = 1 0 0 0 1 0

Es irreducible, es decir, es ergódica. También es recurrente. Pero es periódica. Luego, no es regular. No tiene distribución límite pues Pt no converge: P4=P, P5=P2, P6=P3, P7=P4, etc. Es decir, P1, P2, P3, P4, P5, P6, ... tiene la secuencia P, P2, P3, P, P2, P3, ... No hay el caso en que Pj = Pj+1. Tiene una única distribución estacionaria: w1=1/3, w2=1/3, w3=1/3

16

0.8 0 0.5 0  0.2 0 0.5 0   P=   0 0.5 0 0.2    0 0.5 0 0.8

Es irreducible, es decir, es ergódica. También es recurrente. Y es aperiódica. Luego, es regular. Tiene una única distribución estacionaria: w1=5/14, w2=2/14, w3=2/14, w4=5/14 Que debe coincidir con la distribución límite.

Si se observa detenidamente las condiciones de irreducibilidad y recurrencia, es claro que si hay un camino de un estado a otro estado, para cualquier par de estados, sucede que hay un camino de un estado al mismo estado, para cada estado. Es decir, la irreducibilidad implica recurrencia (la inversa no es cierta). De manera que una fuente ergódica (irreducible) ya es recurrente y sólo falta verificar la aperiodicidad para determinar si es regular o no.

17

FUENTE AFÍN O ADJUNTA DE UNA FUENTE DE INFORMACIÓN DE MARKOV A partir de la Fuente-M, una fuente de información de Markov de orden m, es posible construir una fuente de información de memoria nula llamada Fuente- M (conocida como la fuente afín o adjunta de M). Los símbolos del alfabeto de esta Fuente- M son los mismos que los de la Fuente-M, es decir, S = {s1, s2, ... , sq} Y las probabilidades de emisión de estos símbolos en la Fuente- M , prob(si) = pi, se calculan así:

qm

prob(si) = pi =  p(si /αj) · wj j 1

En el ejemplo de la Fuente-M que estamos siguiendo:

4

prob(s2) = p2 =  p(si /αj) · wj = p(s2/α1) · w1 + p(s2/α2) · w2 + p(s2/α3) · w3 + p(s2/α4) · j 1

w4 = 0.2 · 5/14 + 0.5 · 2/14 + 0.5 · 2/14 + 0.8 · 5/14 = 7/14 = 0.5 prob(s1) = p1 se calcula de manera similar. Luego, la Fuente- M resultante es:

M

pi

s1 s2

0.5 0.5

18

EXTENSIÓN n-ésima DE UNA FUENTE DE MARKOV Sea la Fuente-M una fuente de Markov de orden m con alfabeto S={s1, s2, ... , sq} y matriz de transiciones P. Llamaremos Fuente-Mn a la n-ésima extensión de la Fuente-M original. La Fuente-Mn es también una fuente de Markov que describimos a continuación: Alfabeto: Sn = {1, 2, ... , qn} (qn símbolos). j = sj1 sj2 ... sjn con sji  S n Orden: el orden de la Fuente-M es =techo(m/n) la función techo (ceil en inglés) es la parte entera hacia arriba Probabilidades condicionales:

p(i / j1...j ) (Es claro que existen q = p(si1si2...sin / sj11sj12...sj1n ... sj1sj2...sjn) = p(si1 / sj11sj12...sj1n...sj1sj2...sjn) · p(si2 / sj12...sj1n...sj1sj2...sjnsi1) · ... ... · p(si n / sj1n...sj1sj2...sjnsi1si2...si (n-1))

nμ

estados) (1)

(Debemos redefinir las probabilidades en función de las probabilidades de la Fuente-M original -de orden m-. Para ello en cada una de las probabilidades condicionales sólo se toman en cuenta los últimos m símbolos (después del slash) -los únicos que pueden recordarse-. De manera que (1) se puede reescribir así: sean sh1sh2...shm los últimos m símbolos de "sj11sj12...sj1n ... sj1sj2...sjn" luego) = p(si1 / sh1sh2...shm) · p(si2 / sh2sh3...shmsi1) · p(si3 / sh3sh4...shmsi1si2) · ... ... · p(sin/sh nsh(n+1)...shmsi1si2...si (n-1)) (m≥n) (o bien) = p(si1 / sh1sh2...shm) · p(si2 / sh2sh3...shmsi1) · p(si3 / sh3sh4...shmsi1si2) · ... ... · p(sin/si(n-m)si (n-m+1)...si(n-1)) (m
Ejemplo: Sea la siguiente Fuente-M con S={s1, s2}={0,1}

Los qm=4 estados son: 1=s1s1=00 2=s1s2=01 3=s2s1=10 4=s2s2=11

19

q=2

orden m=2

Listado de probabilidades: p(0/00)=0.8 p(1/00)=0.2 p(0/01)=0.5 p(1/01)=0.5 p(0/10)=0.5 p(1/10)=0.5 p(0/11)=0.2 p(1/11)=0.8

P(1->1)=0.8 p(1->2)=0.2 p(2->3)=0.5 p(2->4)=0.5 p(3->1)=0.5 p(3->2)=0.5 p(4->3)=0.2 p(4->4)=0.8

Matriz de transiciones:

1 2 3 4

00 1 0.8 0.2 0 0

01 2 0 0 0.5 0.5

10 3 0.5 0.5 0 0

11 4 0 0 0.2 0.8

P=

Fuente Extendida-Mn La n-ésima extension de la Fuente-M es con n=2 Sn={1,2,3,4} 1=s1s1=00 2=s1s2=01 3=s2s1=10 4=s2s2=11 orden:

techo(m/n) =  = 1

Conjunto BETA (de estados de la extensión): 1=1=s1s1=00 2=2=s1s2=01 3=3=s2s1=10 4=4=s2s2=11

20

Listado de probabilidades de la fuente extendida: p(00/00)=p(0/00)·p(0/00)=0.8·0.8=0.64 p(00/01)=p(0/01)·p(0/10)=0.5·0.5=0.25 p(00/10)=p(0/10)·p(0/00)=0.5·0.8=0.4 p(00/11)=p(0/11)·p(0/10)=0.2·0.5=0.1 p(01/00)=0.16 p(01/01)=0.25 p(01/10)=0.1 p(01/11)=0.1 p(10/00)=0.1 p(10/01)=0.1 p(10/10)=0.25 p(10/11)=0.16 p(11/00)=0.1 p(11/01)=0.4 p(11/10)=0.25 p(11/11)=0.64

p(1->1)=0.64 p(2->1)=0.25 p(3->1)=0.4 p(4->1)=0.1 p(1->2)=0.16 p(2->2)=0.25 p(3->2)=0.1 p(4->2)=0.1 p(1->3)=0.1 p(2->3)=0.1 p(3->3)=0.25 p(4->3)=0.16 p(1->4)=0.1 p(2->4)=0.4 p(3->4)=0.25 p(4->4)=0.64

Matriz de transición entre estados (de la fuente extendida):

1 2 3 4

00 s1 s1 1 1 0.6400 0.1600 0.1000 0.1000

01 s1 s2 2 2 0.2500 0.2500 0.1000 0.4000

10 s2 s1 3 3 0.4000 0.1000 0.2500 0.2500

11 s2 s2 4 4 0.1000 0.1000 0.1600 0.6400

21

CÓDIGOS Sea X = { t1, t2, ... , tr } un alfabeto de r símbolos. ( Nótese que utilizamos r tanto para la base del logaritmo como para |X| ) X se conoce como el alfabeto (del) código. Denotaremos una secuencia de símbolos en X (una cadena en X+) así: x1x2...xm (xiX). Un código C es una bolsa (bag) finita de n cadenas en X+ (el lenguaje universal excepto la cadena vacía). A diferencia de un conjunto una bolsa permite elementos repetidos. Cuando se prescinda de la repetición de elementos, entonces un código C es un lenguaje finito (un conjunto finito de n cadenas C  X+). Cada cadena de un código C se denomina palabra código (de C). Denotando una palabra código por wi, entonces un código será la bolsa C=[w1, …, wn]; o bien el conjunto C={w1, …, wn}. Ejemplo: con X={t1, t2, t3}={0,1,2} tenemos el código C1=[01,00,11,021,11]; y un otro código C2={00,01,10,11,21,22} (en este último caso, w6 =x1x2=t3t3=22). Es usual escribir un código como una tabla de una columna; para los ejemplos anteriores esto se ve así: C1 C2 -------------------w1 = 01 w1 = 00 w2 = 00 w2 = 01 w3 = 11 w3 = 10 w4 = 021 w4 = 11 w5 = 11 w5 = 21 w6 = 22 Dependiendo del número de símbolos del alfabeto (del) código X, un código se dice binario (cuando r = 2), ternario (cuando r = 3), etc. En general un código C será r-ario. En rigor, no es necesario utilizar los r símbolos en las palabras código de C. En el código C: Si i≠j  wi≠wj, el código se denomina No-Singular, es decir, cuando todas sus palabras código son diferentes (y por tanto representables en un conjunto). En otro caso se denomina Singular, es decir, cuando hay por lo menos dos palabras código (wi,wj ; i≠j) iguales (wi=wj) (y por tanto representables en una bolsa). Es claro que –en los ejemplos- C1 es Singular y que C2 es No-Singular. Dado que la palabra código wi es una cadena, podemos pensar en calcular su longitud, operación que denotaremos así |wi|=li; es decir, li es la longitud de la palabra código wi. En el código C, sea la constante l>0: Si i li=l, el código se denomina Bloque, es decir, cuando todas sus palabras código tienen la misma longitud. En otro caso se denomina no Bloque, es decir, cuando hay por lo menos dos palabras código de diferente longitud. Es claro que –en los ejemplos- C1 es no bloque y que C2 es bloque (con l=2). (Abramson sugiere otro concepto de bloque menos popular pero muy interesante.) 22

En el código C (cuyo alfabeto es X): Si wj wj≠wi·v (con i≠j, v  X*) el código se denomina Libre de Prefijos, es decir, cuando ninguna palabra código es prefijo de otra palabra código diferente. En otro caso se denomina no Libre de Prefijos. Es claro que –en los ejemplos- C1 es no libre de prefijos y que C2 es libre de prefijos.

Es usual considerar los códigos asociados a fuentes de información. Es decir, la palabra código wi se utiliza para representar (codifica) al símbolo si de la fuente. Centraremos nuestra atención en las fuentes de memoria nula. Dado que una Fuente-S tiene q símbolos, su código C asociado tendrá también q palabras código.

Así pues, una representación común de una Fuente-S (genérica) y su código asociado C (genérico) es como sigue:

S s1

pi p1

. . .

. . .

sq

pq

Ejemplo: q=5

S s1 s2 s3 s4 s5

pi 1/5 1/5 1/5 1/5 1/5

C w1 . . . wq

X={a,b,c} C3 b c aa ab ac

Otros códigos para esta Fuente-S son:

C4 aa bb cc ab ba

C5 aa a b bb c

C6 ab ba abb aba ca

Si tenemos el mensaje “ccc” utilizando el código C3, estamos considerando el mensaje w2w2w2, el cual asociaremos a los símbolos s2s2s2. Inicialmente, cuando se codifican fuentes asumiremos que no hay posibilidad de error, es decir, que las cadenas en el alfabeto código corresponden a secuencias de palabras código, mismas que codifican (representan) símbolos de la fuente. Así pues, utilizando el código C3, no tiene sentido considerar mensajes del tipo “abaaba”. En el código C: Si hay una cadena de símbolos del alfabeto código x1x2...xm (con m>0) correspondiente a más de una secuencia de palabras código, C se denomina no Unívocamente Decodificable, es decir, cuando x1x2...xm se puede interpretar de dos o más maneras.

23

En otro caso se denomina Unívocamente Decodificable, es decir, cuando cada secuencia x1x2...xm se puede interpretar de una única manera. Ejemplo: En la última Fuente-S trabajando con el código C5 (con m=2) la cadena x1x2=aa se puede interpretar como w1 que se decodifica como s1; o bien se puede interpretar como w2w2 que se decodifica como s2s2. Dado que hay más de una interpretación posible, es claro que C5 es no Unívocamente Decodificable (es lo mismo decir que C5 no es Unívocamente Decodificable).

Un código C singular, no es unívocamente decodificable: como lo muestra la secuencia x1x2...xm correspondiente a las (por lo menos) dos palabras código iguales. Por ejemplo C=[a,b,a] con la secuencia x1=a, se puede interpretar como w1 o bien como w3. Un corolario obvio es el siguiente: Si C es unívocamente decodificable, entonces C es no singular. Patterson y Sardinas plantearon un teorema -y un método que se deriva de él- para determinar si un código es unívocamente decodificable o no. Se asume que el código es no singular (de hecho hay literatura que define un código unívocamente decodificable C como aquel código no singular que ... etc.) Describimos el método mencionado a continuación: Recordemos las operaciones: i)

Cociente de un lenguaje L entre una cadena u (se llama también conjunto de buenos finales o de sufijos colgantes -respecto de u-): L/u = {w / uw  L} Ejemplo: L={a,b,ab,aaa} u=a L/u ={λ,b,aa} u=aa L/u = {a} Es decir, se buscan las cadenas de L que empiezan con u (las otras no ingresan al cociente), se prescinde de dicho prefijo u y se anotan los símbolos que siguen. Es claro que L/λ = L En rigor, esta operación se denomina cociente izquierdo (ya que existe la operación cociente derecho que anota los prefijos colgantes en vez de los sufijos colgantes).

ii)

Cociente de un lenguaje L1 entre otro lenguje L2: L1/L2 =

U

uL2

L1/u

Está claro que, cuando L2 ={}, L1/L2 = {}

Dos presentaciones equivalentes del método (el código C se trata como lenguaje) son:

24

S0 = C S1 = (C/C) – {λ}

S0 = C

 i≥1 Si+1 = (C/Si)  (Si/C)

 i≥0 Si+1 = [ (C/Si)  (Si/C) ] – {λ}

Cuando Sj = Sk (j
Cuando Sj = Sk (j


Z=



U Si i 1

(nótese que i empieza en 1)

Z=

U S

i

(nótese que i empieza en 1)

i 1

C es unívocamente decodificable si y sólo si λ Z

C es unívocamente decodificable si y sólo si Z∩C ={}

Ejemplos: Con el código C3 de antes y con el método en su segunda presentación. S0 = C3 = {b,c,aa,ab,ac} S1 = [ (C3/S0)  (S0/C3) ] – {λ} = [{λ}  {λ}] – {λ} = { } S2 = [ (C3/S1)  (S1/C3) ] – {λ} = [{ }  { } ] – {λ} = { } S1 = S2 nos detenemos (pues S2=S3=S4= ···). 

Z=

U S

i

={}

i 1

Como Z ∩ C3 = { }, concluimos que C3 es unívocamente decodificable. Con el código C=C6 de antes y con el método en su primera presentación. S0= C = {ab,ba,abb,aba,ca} S1=(C/C) – {λ} = {b,a} S2=(C/S1)  (S1/C)= {a,b,bb,ba}  { } = {a,b,bb,ba} S3=(C/S2)  (S2/C)= {b,bb,ba,a,λ}  {λ} = {λ,a,b,ba,bb} S4=(C/S3)  (S3/C)= {ab,ba,abb,aba,ca,b,bb,a,λ}  {λ} = {λ,a,b,ab,ba,bb,ca,aba,abb} S5=(C/S4)  (S4/C)= {ab,ba,abb,aba,ca,b,bb,a,λ}  {λ,a,b}={λ,a,b,ab,ba,bb,ca,aba,abb} S4 = S5 nos detenemos (pues S5=S6=S7= ···). 

Z=

U S

i

= {λ,a,b,ab,ba,bb,ca,aba,abb}

i 1

Como λ  Z, concluimos que C6 no es unívocamente decodificable.

Sabiendo que un código no es unívocamente decodificable, una cuestión interesante es buscar una secuencia de símbolos del alfabeto código (preferentemente pequeña) que se presta a más de una interpretación (es decir, una secuencia ambigüa). En el ejemplo x1x2...xm = abbaba puede decodificarse como s3s4; o bien como s1s2s2. Se puede plantear esta cuestión de otro modo: buscar dos secuencias diferentes de símbolos de la Fuente-S de la misma longitud que tengan la misma codificación, digamos sj1sj2...sjn y sh1sh2...shn y que ambas se codifiquen idénticamente como x1x2...xm. En este ejemplo, las secuencias buscadas son sj1sj2...sjn=s1s2s2s3s4 y sh1sh2...shn=s3s4s1s2s2 que se codifican igualmente como x1x2...xm=abbabaabbaba.

25

Planteado el problema de ese otro modo, no hay necesidad de generalizarlo buscando dos secuencias diferentes de símbolos de la Fuente-S de distinta longitud (por ejemplo con C={0,00} las secuencias sj=s1s1 y sh=s2), pues si las hubiere se puede construir otras dos secuencias de la misma longitud así: a partir de sj=sj1sj2...sjn y sh=sh1sh2...shñ, con n≠ñ y que se codifiquen idénticamente como x1x2...xm, obtenemos las dos secuencias sjsh y shsj que son secuencias diferentes ¡pero de la misma longitud! además ambas se codifican idénticamente como x1x2...xmx1x2...xm (por ejemplo sjsh=s1s1s2 y shsj=s2s1s1). En el código C: Si es posible decodificar -unívocamente- una cadena de símbolos del alfabeto código x1x2...xm (con m>0) sin conocer qué otros símbolos del alfabeto código siguen, C se denomina Instantáneo. En otro caso se denomina no Instantáneo. Ejemplo: El siguiente caso clarifica bien el concepto de no instantaneidad. Supongamos que una secuencia de símbolos del alfabeto código comienza así: 01 ··· Los puntos suspensivos indican que ignoramos lo que sigue después (incluso ignoramos si hay símbolos después). ¿ Podemos asociar (instantáneamente) y sin dudar una palabra código a dicha secuencia hasta donde la conocemos (es decir, 01) ? Si apresuramos la respuesta y decimos que sí, que corresponde a w2; cometeríamos un grave error si hay luego dos símbolos más (siendo éstos '10'), de manera que la secuencia total es 0110 correspondiente a las palabras código w3w1. Así pues con este código, si una secuencia empieza como 01···, para no cometer errores y no apresurar la respuesta debemos conocer si hay más símbolos o no, y si los hay cuáles son (según sea el código y según sea la secuencia necesitaremos saber uno, dos o más símbolos adicionales). Así pues C es no instantáneo (o, lo que es lo mismo, C no es instantáneo). En cambio, si trabajamos con el código C‟={0,10,110,1110} y una secuencia empieza como 10···, no necesitamos conocer ningún símbolo adicional –ni siquiera conocer si hay más símbolos- para asociar esta secuencia con w2.

S s1 s2 s3 s4

pi

C 1/4 w1=0 1/4 w2=01 1/4 w3=011 1/4 w4=0111

Es obvio que la expresión “sin conocer qué otros símbolos del alfabeto código siguen” se aplica racionalmente cuando estamos –ya- con una palabra código posible de ser asignada. Es decir, no se aplica cuando estamos con una secuencia que no es aún (ni siquiera) una palabra código. Por ejemplo, en C‟ si la secuencia empieza como 11···, es obvio que necesitamos conocer los siguientes símbolos para asociar la secuencia con alguna palabra código (11 no es aún una palabra código). En los códigos bloque no singulares esto es más evidente, por ejemplo con C‟‟={aba,abb,abc}, si una secuencia empieza como a···, claro que tenemos que conocer qué símbolos siguen para empezar a asociar palabras código a la secuencia y a decodificar. C‟ y C‟‟ son instantáneos. Un código instantáneo permite decodificaciones más rápidas (instantáneas, si hacemos honor a su nombre), en cambio un código no instantáneo implica demoras, debido a la necesidad de conocer subsiguientes símbolos.

26

Un código C singular, no es instantáneo: La idea de instantaneidad es que asociemos una secuencia de símbolos del alfabeto código a una palabra código –sin conocer los símbolos siguientes y sin error-. En un código singular el error es evidente cuando interpretamos la secuencia x1x2...xm correspondiente a las (por lo menos) dos palabras código iguales. Por ejemplo C=[a,b,a] con la secuencia x1=a; si bien no hay necesidad de saber los símbolos siguientes, la secuencia se puede interpretar erróneamente como w1 (cuando en realidad corresponde asociar a w3) o bien erróneamente como w3 (cuando en realidad corresponde asociar a w1). Un corolario obvio es el siguiente: Si C es instantáneo, entonces C es no singular. (De hecho hay literatura que define un código instantáneo C como aquel código no singular unívocamente decodificable que ... etc.).

La decodificabilidad unívoca se define mejor a través de la idea de extensión de un código; y la determinación de instantaneidad se facilita con la introducción de algunos resultados teóricos. Prosigamos.

27

EXTENSIÓN DE ORDEN n DE UN CÓDIGO De manera semejante a la extensión de orden n de una fuente de memoria nula, se presenta la idea de la extensión n-ésima de un código. La extensión de orden n de un código C, denotada por Cn, es otro código que se obtiene del código original según se indica a continuación. Sea el código original C={w1, …, wq}

(con alfabeto código X)

El código Cn (extensión de orden n del código C) tiene qn palabras código, que continúan siendo secuencias de símbolos del alfabeto (del) código. Lo denotamos así: Cn = {w1, w2, ... , wqn} donde wj = wj1wj2 ... wjn con wji  C Es decir, las palabras código de Cn son secuencias de n-palabras código de C. Ejemplo: Para el código original C={w1,w2,w3}={0, 11, 00} (cuyo alfabeto es X={0,1}) Su extensión de orden n=3 es: Cn ={w1,w2,w3,w4,w5,w6,w7,w8,w9, ... ,w18,w19,w20,w21,w22,w23,w24,w25,w26,w27} = {w1w1w1, w1w1w2, w1w1w3, w1w2w1, w1w2w2, w1w2w3, w1w3w1, w1w3w2, w1w3w3, w2w1w1, w2w1w2, w2w1w3, w2w2w1, w2w2w2, w2w2w3, w2w3w1, w2w3w2, w2w3w3, w3w1w1, w3w1w2, w3w1w3, w3w2w1, w3w2w2, w3w2w3, w3w3w1, w3w3w2, w3w3w3} = {000, 0011, 0000, 0110, 01111, 01100, 0000, 00011, 00000, 1100, 11011, 11000, 11110, 111111, 111100, 11000, 110011, 110000, 0000, 00011, 00000, 00110, 001111, 001100, 00000, 000011, 000000}

La decodificabilidad unívoca se define formalmente así: Un código C es unívocamente decodificable cuando  k≥1 Ck es no singular. Está claro que tomando k=1 un código unívocamente decodificable debe ser no singular. Es decir, un código singular no es unívocamente decodificable, por definición. En el anterior ejemplo C3 es singular pues 0000=w1w1w3=w3=w7=w1w3w1=0000, luego C no es unívocamente decodificable.

28

PROPIEDADES DE LOS CÓDIGOS 1) C es un código instantáneo si y sólo si C es libre de prefijos. Demostración: =>) Si C es instantáneo entonces C es libre de prefijos. Da lo mismo demostrar la contrarrecíproca del enunciado que es como sigue Si C no es libre de prefijos entonces C no es instantáneo. Dem: Como C no es libre de prefijos, entonces hay (por lo menos) una palabra código wi que es prefijo de otra palabra código diferente wj, es decir, wj wj=wi·v (con i≠j, v  X*), siendo X el alfabeto del código. Cuando v=λ, entonces wj=wi (con i≠j), es decir, C es singular y por lo tanto no instantáneo (ver página 27). Cuando v≠λ, consideremos la secuencia x1x2...xm··· = wi··· (los puntos denotan que no conocemos los siguientes símbolos, ni siquiera si los hay o no). Esta secuencia inicial x1x2...xm no puede asociarse apresuradamente a wi sin la posibilidad de cometer un error, debemos pues conocer si hay más símbolos o no, y si los hay cuáles son (por ejemplo si hay más símbolos que forman la cadena v podríamos estar ante wj y no ante wi). Así pues C no es instantáneo. <=) Si C es libre de prefijos entonces C es instantáneo. Dem: Cuando se tiene una secuencia x1x2...xm = wi ··· (wi cualquier palabra código), entonces la asociación instantánea de esta (sub)cadena a wi (y su decodificación como si) es absolutamente lícita puesto que –por ser C libre de prefijos- ninguna otra palabra código (diferente) tiene a wi como prefijo ( wj wj≠wi·v -con i≠j, v  X*-). Así pues, la interpretación instantánea es buena, y puede continuar si aplicamos el mismo razonamiento recurrentemente a los símbolos que siguen. Luego, C es instantáneo.

2) Si C es un código instantáneo entonces C es unívocamente decodificable. Da lo mismo demostrar la contrarrecíproca del enunciado que es como sigue Si C no es unívocamente decodificable entonces C no es instantáneo. Demostración: Previamente demostraremos que Si Cn no es instantáneo entonces C no es instantáneo. Dem: Cn no es instantáneo. Por el resultado 1), sabemos que Cn no es libre de prefijos, es decir,  wj=wh·v (con h≠j).wh es prefijo de wj. Por la forma de las palabras código en Cn, eso mismo se puede indicar así:  wj1wj2 ... wjn = wh1wh2 ... whn·v (con wji,whk  C; h≠j)

29

Luego, debe suceder (cancelando las primeras palabras código a la izquierda y derecha de la igualdad que sean idénticas, esto sólo para visualizar mejor) que algún wji es prefijo de whi, o bien algún whk es prefijo de wjk , con la importante condición de que hi≠ji, o bien que hk≠jk. [Por ejemplo, con C={0,01}, tenemos C2={00,001,010,0101} que no es instantáneo pues w1=00 es prefijo de w2=001. Como w2=w1w2=w1w1·1=w1·v (con v=1), cancelando el primer w1 (en w1w2=w1w1·1) de manera que terminamos trabajando con ···w2=···w1·1 tenemos que w2 es prefijo de w1, o bien w1 es prefijo de w2 –en realidad esto último, pues w1=0 y w2=01 (aquí hk=h2=1 y jk=j2=2)] Pero entonces –en C- una palabra código es prefijo de otra palabra código diferente. Luego C no es libre de prefijos y, otra vez por el resultado 1), C no es instantáneo. Volvamos a la demostración original: Como C no es unívocamente decodificable, por definición,  k≥1 Ck es singular, es decir, Ck no es instantáneo (como se demuestra en la página 27). Luego, por el resultado previo que acabamos de probar, C no es instantáneo. 3) Si C es un código bloque no singular entonces C es instantáneo. (Es claro que un código bloque singular no es instantáneo ni unívocamente decodificable, como lo prueban los resultados de las páginas 27 y 24). Demostración: Mostraremos que C es libre de prefijos: Como C es bloque, es decir todas las palabras código tienen la misma longitud, ninguna palabra código es prefijo propio de otra (pues en ese caso una tendría longitud menor que la otra y eso no es posible). La única posibilidad que queda para que C no sea libre de prefijos es que una palabra código sea prefijo (no propio) de otra palabra código diferente, esto es que hayan dos palabras código wj,wi con i≠j, tales que wj=wi; ello haría que C sea singular, lo cual está descartado pues C es no singular. Así pues C es libre de prefijos y por el resultado 1) resulta que C es instantáneo.

30

TEOREMA DE KRAFT Existe un código instantáneo C r-ario con longitudes l1, …, lq si y sólo si q



i 1

r – li ≤ 1

En principio probaremos sólo uno de los sentidos del enunciado. q

Si



i 1

r – li ≤ 1 entonces existe un código instantáneo C r-ario con longitudes l1, …, lq

Antes de demostrar el enunciado presentaremos algunos ejemplos de aclaración. Ej. 1: Sea X = {0,1} C = {0,01} donde q=2, l1=1, l2=2, r =2 q



Es claro que

i 1

r – li = 2– 1 + 2– 2 = 1/2 + 1/4 = 3/4 ≤ 1

Esto suele inducir a aseverar que C es instantáneo. Sin embargo, w1=0 es prefijo de w2=01 lo que muestra que C no es libre de prefijos y por lo tanto no es instantáneo. Lo que pasa es que el enunciado no utiliza la palabra “es” sino “existe”. Es decir, que si la desigualdad se cumple, existe un código C instantáneo. El enunciado no debe utilizarse –a partir de un código C- para determinar instantaneidad (como en el ejemplo citado). De hecho, no es necesario partir de un código, sino solamente de longitudes l1, …, lq dadas. Ejemplo: Sean las longitudes l1, …, lq = 2,2,3,3,4 con q=5 y r =2. ¿Existe C instantáneo? q



i 1

r – li

= 2– 2 + 2– 2 + 2– 3 + 2– 3 + 2– 4 ≤ 1

(luego existe C con tales li)

Nótese que la sumatoria en el ejemplo (y en general) siempre se puede reescribir así: = 2·2– 2 + 2·2– 3 + 2– 4 = 0·2– 1 + 2·2– 2 + 2·2– 3 + 1·2– 4 = n1·2– 1 + n2·2– 2 + n3·2– 3 + n4·2– 4 con n1=0, n2=2, n3=2, n4=1

Demostración (del teorema de Kraft en la parte enunciada del si y sólo si): Sea l=max{l1, …, lq}, entonces: q



i 1

r – li =

l



i 1

ni · r –i

donde ni: # de términos de la suma del tipo r –i

Luego, la hipótesis del enunciado –que se asume verdadera- se puede reescribir así: l



i 1

ni · r –i ≤ 1

Es claro que 0 ≤ ni

31

Esta desigualdad no es otra que: n1· r –1 + n2 · r –2 + … + n(l-1)· r – (l-1) + nl· r – l ≤ 1 Si multiplicamos cada miembro por r l (que es positivo y no cambia el sentido de la desigualdad), tenemos: n1· r l–1 + n2 · r l–2 + … + n(l-1)· r l – (l-1) + nl· r l – l ≤ r l es decir, l–1 l–2 1 0 l n1· r + n2 · r + … + n(l-1)· r + nl· r ≤r es decir, l–1 l–2 l n1· r + n2 · r + … + n(l-1)· r + nl ≤r “Despejando” nl queda: 1) nl ≤ r l - n1· r l–1 - n2 · r l–2 - … - n(l-1)· r De 0 ≤ nl y (1) se tiene –por transitividad0 ≤ r l - n1· r l–1 - n2 · r l–2 - … - n(l-1)· r “Despejemos” n(l-1): Primero pasa a la izquierda n(l-1)· r ≤ r l - n1· r l–1 - n2 · r l–2 - … - n(l-2)· r2 Multiplicando cada miembro por 1/r (que es positivo) 2) n(l-1) ≤ r l–1 - n1· r l–2 - n2 · r l–3 - … - n(l-2)· r Análogamente, de 0 ≤ n(l-1) y (2) se tiene –por transitividad0 ≤ r l–1 - n1· r l–2 - n2 · r l–3 - … - n(l-2)· r Otra vez, análogamente, “despejando” n(l-2) tenemos 3) n(l-2) ≤ r l–2 - n1· r l–3 - n2 · r l–4 - … - n(l-3)· r … Si hacemos lo mismo para cada ni tenemos que … las tres últimas desigualdades son: l-2) n3 ≤ r3 - n1· r2 – n2· r l-1) n2 ≤ r2 - n1· r l) n1 ≤ r Reescribiendo las desigualdades 1) a l) tenemos: nl ≤ r l - n1· r l–1 - n2 · r l–2 - … - n(l-1)· r n(l-1) ≤ r l–1 - n1· r l–2 - n2 · r l–3 - … - n(l-2)· r n(l-2) ≤ r l–2 - n1· r l–3 - n2 · r l–4 - … - n(l-3)· r … n3 ≤ r3 - n1· r2 – n2· r n2 ≤ r2 - n1· r n1 ≤ r Dado que la hipótesis se asume cierta y estas desigualdades provienen de ella (utilizando y realizando operaciones válidas), resulta que también son ciertas. La demostración de Kraft, más que un código C r-ario concreto, lo que nos ofrece es una idea –un esquema- de cómo construir dicho código junto a la argumentación de que tal construcción producirá uno instantáneo. Y es como sigue:

32

Tiene Usted r símbolos en el alfabeto código X. Cómo empezar a construir palabras

Cómo precautelar la instantaneidad

De entre los r símbolos de X, elija n1 palabras código de longitud 1.

Cuide que n1 ≤ r De lo contrario habría singularidad.

Elija n2 palabras código de longitud 2. De esas hay: símbolo 1º símbolo 2º cualquiera de r cualquiera de r

Pero como ya eligió n1 palabras de longitud 1, esas no pueden ser prefijo de ninguna otra, es decir, cuide que el 1º símbolo no sea cualquiera de r, sino cualquiera de r- n1; el 2º símbolo sí puede ser cualquiera de r; así sólo puede elegir de entre (r-n1)·r, es decir, n2 ≤ r2 - n1· r

Es decir, pueden construirse arbitrariamente hasta r·r = r2 palabras código de longitud 2. Elija n3 palabras código de longitud 3. De esas hay: símbolos 1º y 2 º símbolo 3 º r2 r Es decir, pueden construirse arbitrariamente hasta r2·r = r3 palabras código de longitud 3.

Pero, para preservar que C sea libre de prefijos, cuide que los dos primeros símbolos no sean los ya elegidos. Estos eran a lo más (r-n1)·r= r2-n1· r, debe restárseles los n2 ya elegidos en el paso anterior, es decir, los dos primeros símbolos pueden ser cualquiera de r2 - n1· r – n2 ; el tercer símbolo sí puede ser cualquiera de r; es decir, n3 ≤ r3 - n1· r2 – n2· r

El mismo esquema se puede seguir hasta elegir las nl palabras código de longitud l. Para que el esquema funcione y produzca un código instantáneo (asegurando de no elegir como prefijo las palabras código ya elegidas), las desigualdades de la columna que „cuida‟ la instantaneidad deben verificarse. Pero ello sí sucede como puede verse de las desigualdades (1) a (l), ya demostradas verdaderas. Así pues un código C r-ario de longitudes l1, …, lq sí existe, lo que concluye la demostración. Una aplicación común del esquema de construcción del código C en el teorema de Kraft utiliza árboles como instrumento y puede verse en el siguiente ejemplo. Sean l1, …, lq = 2,2,3 con q=3, r =3 y X={0,1,2}, l=max{l1, l2, l3}=3 q

Dado que



i 1

r – li =

3– 2 + 3– 2 + 3– 3

= 1/9 + 1/9 + 1/27 = 7/27

= n1·3– 1 + n2·3– 2 + n3·3– 3 ≤ 1

con n1=0, n2=2, n3=1

Luego, el teorema dice que sí existe un código C r-ario con esas longitudes. Construyámoslo: Utilizaremos un árbol r-ario (cada nodo tiene r hijos). Los nodos hijo se etiquetan con los símbolos de X (en orden lexicográfico).

33

Un camino que va de la raíz a un nodo hoja representa una palabra código. Una vez elegida una palabra código, su rama ya no crece (lo señalamos -aquí- con un nodo hoja cuadrado): para cuidar que esta palabra no sea prefijo de otra palabra código. De la raiz expandimos el árbol en un nivel:

Elegimos n1=0 palabras código de longitud 1 (ninguna) Todas las ramas se expanden. El resultado de la expansión es:

Elegimos n2=2 palabras código de longitud 2 (por ejemplo en orden lexicográfico). Aquí elegimos w1=00 y w2=01 Esta ramas se truncan (lo señalamos con un nodo hoja cuadrado) Las otras se expanden. El resultado de la expansión es:

Elegimos n3=1 palabras código de longitud 3. Aquí elegimos w3=020 Las otras se expanden (a no ser que hayamos terminado, que es nuestro caso). Así pues el código construido es C = {w1,w2,w3} = {00,01,020} Que como cuida el esquema, es libre de prefijos, es decir, instantáneo.

Hay una demostración alternativa encontrada en el paper de Nguyen Hung Vu (para r=2) que aquí la generalizamos para cualquier r. Lo interesante de esta demostración es que construye C explícitamente.

34

Repetimos el enunciado (en uno de los sentidos si … entonces …). q

Si



i 1

r – li ≤ 1 entonces existe un código instantáneo C r-ario con longitudes l1, …, lq

Demostración: Sin pérdida de generalidad se supone que l1 ≤ l2 ≤…≤ l(q-1) ≤ lq (reordenando si es necesario). Construimos las q palabras código de C en dos fases. Fase I. Construcción de q números. v1 = 0 j 1

vj =



i 1

r lj – li

(para j=2,…,q)

Fase II. Construcción de q palabras código. wj es la representación r-aria de vj añadiendo ceros a la izquierda cuando sea necesario, es decir, cuando el número de símbolos de la representación r-aria de vj sea < lj Al interior de esta demostración incluimos el siguiente par de ejemplos: Sean l1, l2, l3, l4, l5 = 2,2,3,3,4 con q=5 r=2 r=3 q



i 1

r

– li

q

= 1/4 + 1/4 + 1/8 + 1/8 + 1/16



i 1

= 13/16 ≤ 1 Construyamos C: Fase I: v1 = 0 v2 = 1 v3 = 4 v4 = 5 v5 = 12

r – li = 1/9 + 1/9 + 1/27 + 1/27 + 1/81 = 25/81 ≤ 1

Fase II: w1 = 00 w2 = 01 w3 = 100 w4 = 101 w5 = 1100

Construyamos C: Fase I: v1 = 0 v2 = 1 v3 = 6 v4 = 7 v5 = 24

Fase II: w1 = 00 w2 = 01 w3 = 020 w4 = 021 w5 = 0220

Los ceros en negrita son los que se añadieron a la izquierda.

Los ceros en negrita son los que se añadieron a la izquierda.

Nótese que C es libre de prefijos.

Nótese que C es libre de prefijos.

Continuamos con la demostración. Probaremos dos cosas: a) Que el número de símbolos de la representación r-aria de vj es ≤ lj b) Que wj no es prefijo de wk (para j < k) ¿ Cuántos símbolos son necesarios para la representación r-aria de vj ? Aunque no formalizaremos este resultado algunos ejemplos pueden aclarar la fórmula que presentaremos. Debe ser claro que no deseamos cambiar vj de base y luego contar el número de símbolos en la representación resultante (aunque mostremos esto en los ejemplos, por claridad).

35

log2(8) = log2(23) = 3 Si 23 ≤ num < 24 cualquier número (num) entre 8 y 15 requiere 3+1 = 4 símbolos para su representación 2-aria Por ej. (8)2 = 1000 log2(8) = 3.0

(10)2 = 1010 log2(10) = 3.321

(15)2 = 1111 log2(15) = 3.9

log2(16) = log2(24) = 4


(22)2 = 10110 log2(22) = 4.459

(31)2 = 11111 log2(31) = 4.954

log2(32) = log2(25) = 5


(17)3 = 122 log3(17) = 2.578

(26)3 = 222 log3(26) = 2.965

log3(27) = log3(33) = 3

| número de símbolos para la representación r-aria de vj | = [logr (vj)]+ 1 [y] denota la parte entera de y Es obvio que la representación r-aria de v1 = 0 es: 0 Luego, | número de símbolos para la representación r-aria de v1 | = 1

36

a) Es lógico pensar que lj > 0 (no hay palabras código de longitud cero), es decir, 1 ≤ lj (para j=1,…,q) Es evidente que |número de símbolos para la representación r-aria de v1| ≤ l1 Para el caso vj (j=2,…,q), mostraremos que: j 1

(1)



i 1

r – li < 1 j 1

En efecto,



r – li <

i 1

q



i 1

r – li

Pues j=2,…,q ; es decir, j≤q, luego (j-1)
≤1 j 1

(2) logr (  r – li) < 0

Por (1) y propiedades de logaritmo

i 1

j 1

(3) logr (vj) = lj + logr (  r – li) i 1

En efecto,

j 1

logr (vj) = logr (  r lj – li )

Por definición de vj

i 1 j 1

= logr (  r lj · r – li )

Obvio

i 1

j 1

= logr (r lj ·  r – li ) i 1

Pues la variable de la sumatoria es i

j 1

= logr (r lj ) + logr (  r – li ) =

lj

(4) logr (vj) < lj En efecto,

i 1 j 1

+ logr (  r – li ) i 1

Logaritmo de un producto Obvio

j 1

logr (vj) = lj + logr (  r – li) i 1

< lj (5) Se sabe que [y] ≤ y (6) [logr (vj)] < lj Luego, (7) [logr (vj)] + 1 ≤ lj

Por (3) j 1

Pues logr (  r – li) < 0 por (2) i 1

Por (5) y (4) Pues si y < z, entonces y+1 ≤ z en los enteros

Es decir, | número de símbolos para la representación r-aria de vj | ≤ lj 37

El inciso a) muestra que el procedimiento tiene sentido cuando añade ceros a la izquierda si es necesario; y que las longitudes lj son suficientes para albergar a las palabras código wj (es decir, nunca faltará espacio). b) Lo subdividimos en dos partes: b1) w1 no es prefijo de ningún otro wj (j=2,…,q) Sólo por claridad haremos un uso “gráfico” de los puntos suspensivos: Mostraremos que cuando w1 = 0.…...0 no puede ser que wj = 0……0…0w‟ ( w‟ son los restantes símbolos de wj) sino que los ceros que se añaden a wj –si es necesario- son menos que los ceros en w1 es decir que: wj = 0…0w‟ j 1

En efecto, sabemos que: vj =



i 1

r

lj – li

= r

lj – l1

j 1

+



i 2

r lj – li

Es claro que la representación r-aria de vj requiere tantos (o más) símbolos como la representación r-aria de la parte subrayada solamente. También sabemos que: | número de símbolos para la representación r-aria de r lj – l1 | = [logr (r lj – l1)] + 1 = lj – l1 + 1 Es decir, la representación r-aria de vj requiere (lj – l1 + 1) símbolos o más; es decir, la representación r-aria de vj requiere por lo menos (lj – l1 + 1) símbolos. Tenemos reservados lj símbolos – o lugares, o celdas, o espacios - para wj. Si la representación r-aria de vj requiere por lo menos (lj – l1 + 1) símbolos, entonces, por simple deducción (de los lj lugares) quedan ( lj - (lj – l1+1) ) que rellenar con ceros. Pero, ( lj - (lj – l1+1) ) = l1-1. Es decir, a lo más se añaden ( l1-1 ) ceros . Es decir, los ceros que se añaden son menos que los l1 ceros de que consta w1. Es decir, w1 no es prefijo de ningún otro wj (j=2,…,q). b2) Para el caso wj (j=2,…,q). Mostraremos que ningún wj es prefijo de otro wk (2 ≤ j < k ≤ q) Por reducción al absurdo supondremos que sí, que algún wj es prefijo de otro wk (j
38

Luego wj no puede ser prefijo de wk evidentemente. Es decir, para que wj sea prefijo de wk, la cantidad de ceros añadidos a la izquierda (si es el caso) debe coincidir en ambas palabras código. Esto puede visualizarsese así: wj = 0.…...0(vj)r (vj)r es la representación r-aria de vj wk = 0……0(vk)r (vk)r es la representación r-aria de vk Es decir, para que wj sea prefijo de wk debe ser que (vj)r es prefijo de (vk)r Aunque no formalizaremos el siguiente resultado, el lector puede hacer algunos ejemplos, para aclarar que el hecho que (vj)r sea prefijo de (vk)r puede establecerse -en base 10, es decir trabajando con vj,vk- así: vj = [vk / r lk – lj ] (recuerde que j
lk – lj

j 1

=



i 1

r lj – li + 1 +

k 1



r lj – li

i  j 1

En efecto: k 1

vk / r lk – lj = (  r lk – li )

/

i 1

( r lk – lj )

Por definición de vk

k 1

= ( r lj – lk ) · (  r lk – li )

Sube el denominador al numerador

i 1

k 1



r lk – li · r lj – lk

Introducimos r lj – lk a la sumatoria

=



r lj – li

Obvio

=



r lj – li +

=



r lj – li +  r lj – li +

=



r lj – li +

r lj – lj +

=



r lj – li +

1

=

i 1 k 1 i 1 j 1

i 1 j 1 i 1 j 1 i 1 j 1 i 1

k 1

 i j

r lj – li

Pues j
j

k 1

i j

i  j 1



r lj – li

k 1



i  j 1 k 1

+



i  j 1

r lj – li

Obvio

r lj – li

Obvio

(3) [y] +1 > y (4) [vk / r lk – lj ] + 1 > vk / r lk – lj (5) vj + 1 > vk / r lk – lj j 1

(6) vj + 1 >



i 1

r lj – li + 1 +

k 1



i  j 1

Obvio (véase bien los rangos de i)

Obvio Por (3) Pues vj = [vk / r lk – lj] y de (4) r lj – li

Por (2)

39

j 1

(7)



i 1

r lj – li + 1 + j 1

k 1



i  j 1

r lj – li ≥

(8) vj + 1 >



r lj – li + 1 +

(9) vj + 1 >



r lj – li + 1

i 1 j 1 i 1

k 1



i  j 1

j 1



i 1

r lj – li + 1

r lj – li ≥

j 1



i 1

k 1

Pues

r lj – li + 1



i  j 1

r lj – li puede ser vacua

Juntando (6) y (7) De (8) j 1

(10) vj + 1 > vj + 1

Pues vj =



i 1

r lj – li

Lo que es claramente una contradicción. Así pues nuestro supuesto debe estar errado (wj es prefijo de wk), y el enunciado “ningún wj es prefijo de otro wk (2 ≤ j < k ≤ q)” es cierto. Por b1) y b2) C es libre de prefijos, es decir, instantáneo.

40

TEOREMA DE McMILLAN Existe un código unívocamente decodificable C r-ario con longitudes l1, …, lq si y sólo si q



i 1

r – li ≤ 1

En principio probaremos sólo uno de los sentidos del enunciado. Si existe un código unívocamente decodificable C r-ario con longitudes l1, …, lq q

entonces q

Sea K =



i 1



i 1

r – li ≤ 1

r – li

Trabajaremos con Kn para n>0 q

¿ Cómo podemos reescribir K = (  r – li)n ? n

i 1

Un ejemplo aclarará nuestra reescritura: (r –l1 + r –l2 + r –l3 + r –l4)3 = (r –l1 + r -l2 + r -l3 + r -l4) · (r -l1 + r -l2 + r -l3 + r -l4) · (r -l1 + r -l2 + r -l3 + r -l4) = (r -l1·(r -l1 + r -l2 + r -l3 + r -l4) + r -l2·(r -l1 + r -l2 + r -l3 + r -l4) + r -l3·(r -l1 + r -l2 + r -l3 + r -l4) + r -l4·(r -l1 + r -l2 + r -l3 + r -l4))

·(r -l1 + r -l2 + r -l3 + r -l4)

= ( r -l1·r -l1 + r -l1·r -l2 + r -l1·r -l3 + r -l1·r -l4 + r –l2·r -l1 + r –l2·r -l2 + r –l2·r -l3 + r –l2·r -l4 + r –l3·r -l1 + r –l3·r -l2 + r –l3·r -l3 + r –l3·r -l4 + r –l4·r -l1 + r –l4·r -l2 + r –l4·r -l3 + r –l4·r -l4 ) = r -l1·r -l1·(r -l1 + r -l2 + r -l3 + r -l4) + r -l1·r -l2·(r -l1 + r -l2 + r -l3 + r -l4) + r -l1·r -l3 ·(r -l1 + r -l2 + r -l3 + r -l4) + r -l1·r -l4·(r -l1 + r -l2 + r -l3 + r -l4) + r –l3·r -l1·(r -l1 + r -l2 + r -l3 + r -l4) + r –l3·r -l2·(r -l1 + r -l2 + r -l3 + r -l4) + r –l3·r -l3·(r -l1 + r -l2 + r -l3 + r -l4) + r –l3·r -l4·(r -l1 + r -l2 + r -l3 + r -l4)

·(r -l1 + r -l2 + r -l3 + r -l4) + r –l2·r -l1·(r -l1 + r -l2 + r -l3 + r -l4) + r –l2·r -l2·(r -l1 + r -l2 + r -l3 + r -l4) + r –l2·r -l3·(r -l1 + r -l2 + r -l3 + r -l4) + r –l2·r -l4·(r -l1 + r -l2 + r -l3 + r -l4) + r –l4·r -l1·(r -l1 + r -l2 + r -l3 + r -l4) + r –l4·r -l2·(r -l1 + r -l2 + r -l3 + r -l4) + r –l4·r -l3·(r -l1 + r -l2 + r -l3 + r -l4) + r –l4·r -l4·(r -l1 + r -l2 + r -l3 + r -l4)

41

= r -l1·r -l1·r -l1 + r -l1·r -l1·r –l2 + r -l1·r -l1·r –l3 + r -l1·r -l1·r –l4 + r -l1·r –l2·r -l1 + r -l1·r –l2·r –l2 + r -l1·r –l2·r –l3 + r -l1·r –l2·r –l4 + r -l1·r –l3·r -l1 + r -l1·r –l3·r –l2 + r -l1·r –l3·r –l3 + r -l1·r –l3·r –l4 + r -l1·r –l4·r -l1 + r -l1·r –l4·r –l2 + r -l1·r –l4·r –l3 + r -l1·r –l4·r –l4 + r –l2·r -l1·r -l1 + r –l2·r -l1·r –l2 + r –l2·r -l1·r –l3 + r –l2·r -l1·r –l4 + r –l2·r –l2·r -l1 + r –l2·r –l2·r –l2 + r –l2·r –l2·r –l3 + r –l2·r –l2·r –l4 + r –l2·r –l3·r -l1 + r –l2·r –l3·r –l2 + r –l2·r –l3·r –l3 + r -l2·r –l3·r –l4 + r –l2·r –l4·r -l1 + r –l2·r –l4·r –l2 + r –l2·r –l4·r –l3 + r –l2·r –l4·r –l4 + r –l3·r -l1·r -l1 + r –l3·r -l1·r –l2 + r –l3·r -l1·r –l3 + r –l3·r -l1·r –l4 + r –l3·r –l2·r -l1 + r –l3·r –l2·r –l2 + r –l3·r –l2·r –l3 + r –l3·r –l2·r –l4 + r –l3·r –l3·r -l1 + r –l3·r –l3·r –l2 + r –l3·r –l3·r –l3 + r –l3·r –l3·r –l4 + r –l3·r –l4·r -l1 + r –l3·r –l4·r –l2 + r –l3·r –l4·r –l3 + r –l3·r –l4·r –l4 + r –l4·r -l1·r -l1 + r –l4·r -l1·r –l2 + r –l4r -l1·r –l3 + r –l4·r -l1·r –l4 + r –l4·r –l2·r -l1 + r –l4·r –l2·r –l2 + r –l4·r –l2·r –l3 + r –l4·r –l2·r –l4 + r –l4·r –l3·r -l1 + r –l4·r –l3·r –l2 + r –l4·r –l3·r –l3 + r –l4·r –l3·r –l4 + r –l4·r –l4·r -l1 + r –l4·r –l4·r –l2 + r –l4·r –l4·r –l3 + r –l4·r –l4·r –l4 (sumando los exponentes de r con el signo “–” „afuera‟ queda) = r –(l1+l1+l1) + r –(l1+l1+l2) + r –(l1+l1+l3) + r –(l1+l1+l4) + r –(l1+l2+l1) + r –(l1+l2+l2) + r –(l1+l2+l3) + r –(l1+l2+l4) + r –(l1+l3+l1) + r –(l1+l3+l2) + r –(l1+l3+l3) + r –(l1+l3+l4) + r –(l1+l4+l1) + r –(l1+l4+l2) + r –(l1+l4+l3) + r –(l1+l4+l4) + r –(l2+l1+l1) + r –(l2+l1+l2) + r –(l2+l1+l3) + r –(l2+l1+l4) + r –(l2+l2+l1) + r –(l2+l2+l2) + r –(l2+l2+l3) + r –(l2+l2+l4) + r –(l2+l3+l1) + r –(l2+l3+l2) + r –(l2+l3+l3) + r –(l2+l3+l4) + r –(l2+l4+l1) + r –(l2+l4+l2) + r –(l2+l4+l3) + r –(l2+l4+l4) + r –(l3+l1+l1) + r –(l3+l1+l2) + r –(l3+l1+l3) + r –(l3+l1+l4) + r –(l3+l2+l1) + r –(l3+l2+l2) + r –(l3+l2+l3) + r –(l3+l2+l4) + r –(l3+l3+l1) + r –(l3+l3+l2) + r –(l3+l3+l3) + r –(l3+l3+l4) + r –(l3+l4+l1) + r –(l3+l4+l2) + r –(l3+l4+l3) + r –(l3+l4+l4) + r –(l4+l1+l1) + r –(l4+l1+l2) + r –(l4+l1+l3) + r –(l4+l1+l4) + r –(l4+l2+l1) + r –(l4+l2+l2) + r –(l4+l2+l3) + r –(l4+l2+l4) + r –(l4+l3+l1) + r –(l4+l3+l2) + r –(l4+l3+l3) + r –(l4+l3+l4) + r –(l4+l4+l1) + r –(l4+l4+l2) + r –(l4+l4+l3) + r –(l4+l4+l4)

42

4

=

4

4

  

r –(li1+li2+li3)

i11 i 21 i 31

Así pues, es claro que –en general-: q

Kn = (  r – li)n i 1

= (r –l1 + r –l2 + … + r –l(q-1) + r lq)n = (r –l1 + r –l2 + … + r –l(q-1) + r –lq) · … … · (r –l1 + r –l2 + … + r –l(q-1) + r –lq) veces] q

=

q



…

i11



in1

[n

r –(li1+ … +lin)

Sea l=max{l1, …, lq}. Si utilizamos el mismo razonamiento que en el Teorema de Kraft, esta sumatoria puede reescribirse así: q



i11

q

…



in1

r –(li1+ … +lin) =

q

Es decir, Kn = (  r – li)n = i 1

n·l

 i n n·l

 i n

Ni · r –i donde Ni: # de términos de la suma del tipo r –i Ni · r –i

Nótese que en la última sumatoria, la variable i va desde n pues suponiendo que todos los lij = 1, entonces r –(li1+ … +lin) = r –(1+ … +1) = r –n. Que es el caso más pequeño. En cambio, i va hasta n·l pues suponiendo que todos los lij = l, entonces r –(li1+ … +lin) = r –(l+ … +l) = r –n·l. Que es el caso más grande. Por otro lado, sabemos –por hipótesis del enunciado- que el código C existe, es r-ario y sus palabras código tienen longitudes l1, …, lq. Es interesante -y útil- observar qué sucede con su extensión n-ésima, es decir, con Cn (en particular con las longitudes de las palabras código de esta extensión). Consideremos primero un ejemplo: C={w1,w2,w3,w4} con longitudes l1,l2,l3,l4 respectivamente. Sea n=3, luego: Anotamos a continuación las cadenas de Cn y sus longitudes.

43

w1 w1 w1 | l1 + l1 + l1 w1 w1 w2 | l1 + l1 + l2 w1 w1 w3 | l1 + l1 + l3 w1 w1 w4 | l1 + l1 + l4 w1 w2 w1 | l1 + l2 + l1 w1 w2 w2 | l1 + l2 + l2 w1 w2 w3 | l1 + l2 + l3 w1 w2 w4 | l1 + l2 + l4 w1 w3 w1 | l1 + l3 + l1 w1 w3 w2 | l1 + l3 + l2 w1 w3 w3 | l1 + l3 + l3 w1 w3 w4 | l1 + l3 + l4 w1 w4 w1 | l1 + l4 + l1 w1 w4 w2 | l1 + l4 + l2 w1 w4 w3 | l1 + l4 + l3 w1 w4 w4 | l1 + l4 + l4




En general, sea C={w1,…,wq} con longitudes l1, …, lq Las longitudes de las cadenas de Cn son: l1 + …+ l1 l1 + …+ l2 … lq + …+ lq-1 lq + …+ lq Nótese que son las mismas expresiones que aparecen en los exponentes de: q

K = ( r n

i 1

q

) = …

– li n

i11

q



in1

r –(li1+ … +lin)

Entonces también Ni puede representar el # de palabras código –en Cn – de longitud i. Resumiendo: q

Kn = (  r – li)n = i 1

n·l

 i n

Ni · r –i

Donde Ni: # de palabras código –en Cn – de longitud i Ni: # de términos de la suma del tipo r –i (Ni sirve bien para ambos usos). ¿Cuántas palabras código r-arias de longitud i pueden formarse arbitrariamente? Es claro, que ri. Además, sabemos que C es unívocamente decodificable. Luego todas sus extensiones son no singulares por definición. Es decir, Ni ( # de palabras código –en Cn – de longitud i) debe ser menor o igual que ri.

44

Ni ≤ ri Lo contrario (Ni > ri), dado que sólo existen ri diferentes palabras código de longitud i, significaría que se repiten palabras, es decir, que Cn es singular, lo que no es posible. Luego, Kn =

n·l

 i n

Ni · r –i ≤ =

n·l

 i n n·l



i n

r i · r –i r i–i =

Pues Ni ≤ ri n·l



i n

r0 =

n·l



i n

1

= n· l - n + 1

Obvio Obvio

Es decir, q

(  r – li)n = Kn ≤ n· l - n + 1 i 1 q

y como n· l - n + 1≤ n· l,

entonces

(  r – li)n = Kn ≤ n· l i 1

Una función exponencial (de n) menor o igual que una funcion lineal (de n). La única forma de que ello suceda es cuando la raíz del exponente es ≤ 1, es decir: q



i 1

r – li ≤ 1.

Que es lo que queríamos demostrar. En el Anexo 2 se demuestra que (para l>0): Si x>0 Kx  x·l entonces K  1 Que es precisamente el resultado que se utiliza.

45

Hemos demostrado: 1) Si existe un código unívocamente decodificable C r-ario con longitudes l1, …, lq q

entonces q

2) Si



i 1



i 1

r – li ≤ 1

[McMillan]

r – li ≤ 1

entonces existe un código instantáneo C r-ario con longitudes l1, …, lq 3) Si C es un código instantáneo entonces C es unívocamente decodificable Lícitamente podemos reescribir 3 como: 3') Si  C un código instantáneo entonces  C unívocamente decodificable

[Kraft] [página 29]

Luego, de 3' y 1, por transitividad: 4) Si  C un código instantáneo r-ario con longitudes l1, …, lq q

entonces



i 1

r – li ≤ 1

También, de 2 y 3', por transitividad: q

5) Si



i 1

r – li ≤ 1

entonces  un código unívocamente decodificable C r-ario con longitudes l1, …, lq Finalmente, La conjunción de 4 y 2 resultan en:

La conjunción de 1 y 5 resultan en:

 C un código instantáneo r-ario con longitudes l1, …, lq si y sólo si q



i 1

 C un código unívocamente decodificable r-ario con longitudes l1, …, lq si y sólo si q



r – li ≤ 1

Que es el Teorema de Kraft.

i 1

r – li ≤ 1

Que es el Teorema de McMillan.

46

Una propiedad muy útil es la siguiente: ln(x)  x-1

(dándose la igualdad en x=1)

Demostración (hallada en el libro de Jones): Supongamos que x > 0. Sea La primera derivada es La segunda derivada es

f(x) = (x -1) - ln(x) f '(x) = 1 - 1/x f ''(x) = 1/x2

Es claro que f ''(x) > 0 ¿ Cuándo f '(x) = 0 ? 1 - 1/x = 0 cuando x = 1 Así x = 1 es un punto crítico de f(x), y como f ''(x) > 0, x = 1 es un punto mínimo. Además como f(1) = (1-1) - ln(1) = 0 - 0 = 0 tenemos que f(x)= (x -1) - ln(x)  0, es decir: x - 1  ln(x)

ln(x) ≤ x - 1

o, lo que es lo mismo,

47

LEMA DE GIBBS Si {x1, ..., xq}, {y1, ..., yq} son dos conjuntos de números tales que q

xi  0, yi  0



además que

i 1

q



xi = 1,

i 1

yi = 1

Entonces q



i 1

xi· ln(1/xi) 

q



xi· ln(1/yi)

i 1

Demostración: q

q



xi· ln(1/xi) -

=



[ xi· ln(1/xi) - xi· ln(1/yi) ]

propiedades de sumatoria

=



xi · [ ln(1/xi) - ln(1/yi) ]

factorizando xi

=



xi · [ ln( (1/xi) / (1/yi) )]

ln(a/b) = ln a - ln b

=



xi · [ ln(yi /xi)]

medios con medios, extremos con extremos





x i · [yi/xi - 1]

pues ln(z)  z -1 (igualdad en z=1) (aquí z= yi/xi)

=



[ yi - xi ]

distribuyendo xi

=



yi -



= =

1 0

-

1

i 1 q

i 1 q i 1 q i 1 q i 1 q

i 1 q i 1 q

i 1



i 1

xi· ln(1/yi)

q

i 1

xi

'desdoblando' la sumatoria por los supuestos del lema

Resumiendo: q



i 1

q

xi· ln(1/xi) q

Es decir,



i 1



i 1

xi· ln(1/yi)  0

xi· ln(1/xi) 

q



i 1

xi· ln(1/yi)

La igualdad se da cuando yi/xi=1, es decir, cuando xi=yi

48

PROPIEDADES DE LA ENTROPÍA En una fuente de memoria nula. Sea Fuente-S una fuente de memoria nula. 1) Hr(S)  0 Demostración: q

Hr(S) =

Recordemos que



i 1

pi · logr 1/pi

r-its

Ya vimos que pi · logr (1/pi )  0 El resultado sigue inmediatamente. 2) Hr(S)  logr(q) Demostración: Sean xi = pi , yi = 1/q q

Es claro que xi  0, yi  0

además que



i 1

q

xi = 1,



i 1

yi = 1

Es decir, los supuestos de Gibbs se mantienen y podemos aplicar el lema. Luego, q

q



pi · ln(1/pi) 



pi · logr(1/pi) /logr(e) 



pi · logr(1/pi) 



pi · logr(q)

cancelando logr(e) (logr(e)>0)

Hr(S)





pi · logr(q)

por definición de entropía

Hr(S)

 logr(q)

Hr(S)

 logr(q)

i 1 q i 1 q i 1



i 1

pi · ln(q)

O su equivalente:

q



i 1

pi · logr(q) /logr(e)

pues ln(z)=logr(z)/logr(e)

q

i 1 q

i 1

q



i 1

pi

pues logr(q) no depende de i pues la sumatoria es igual a 1

Juntando los dos resultados anteriores tenemos los límites o el rango de la entropía: 0  Hr(S)  logr(q)

49

H(Sn) = n·H(S) Demostración: Sea la Fuente-Sn (extensión de orden n de la Fuente-S) con alfabeto Sn = {1, 2, ... , qn}, donde j = sj1 sj2 ... sjn con sji  S. Por definición, la entropía de esta fuente extendida es:

qn

H(S ) =  [ prob(j) ] · [ logr 1/prob(j) ] n

j1 qn

=  [pj1 · ... · pjn ] · [logr 1/pj1 · ... · pjn] j1

pues prob(j) = prob(sj1 sj2 ... sjn) = prob(sj1) · ... · prob(sjn) = pj1 · ... · pjn

Nótese que esta sumatoria recorre las probabilidades de cada uno de los símbolos de Sn: p1 · ... · p1 · p1 (n veces); p1· ... · p1 · p2; etcétera hasta llegar a pq · ... · pq · pq (n veces). Por ello, es lícito reescribir H(Sn) así: H(Sn) q

=



i11 q

q

…

= … i11



[pi1 · pi2 · ... · pin ] · [logr 1/pi1 · pi2 · ... · pin]



[pi1 · pi2 · ... · pin ] · [logr (1/pi1 · 1/pi2 · ... · 1/pin)]

in1 q

in1

reescribiendo el 2o

corchete q

= … i11

q



in1

[pi1 · pi2 · ... · pin ] · [logr(1/pi1 ) + logr(1/pi2 ) ... + logr(1/pin)]

log de

producto q

= …

q



[pi1 · pi2 · ... · pin ] · logr(1/pi1 )

distribuyendo el primer corchete



[pi1 · pi2 · ... · pin ] · logr(1/pi2)

e introduciendo las

i11 q

in1 q

i11

in1

+ … ... q

+ … i11

sumatorias q



in1

[pi1 · pi2 · ... · pin ] · logr(1/pin)

= H(S) + H(S) ... + H(S)

pues cada uno de los n sumandos es igual a la entropía H(S) como enseguida probaremos.

= n·H(S)

Que es lo que queríamos demostrar

50

Que cada uno de los n sumandos sea igual a entropía de la fuente original, puede verse con el siguiente razonamiento para dos de ellos: Caso i1: q



i11 q

q

…

= … i11 q



[pi1 · pi2 · ... · pin ] · logr(1/pi1)



[pi1 · logr(1/pi1)] · pi2 · ... · pin

in1 q

in1

=  [pi1 · logr(1/pi1)]

q

i 21 q

i11

i 21

=  [pi1 · logr(1/pi1)]

q



i11 q

Obvio

…





pi2 · ... · pin

in1 q

Pues i1 no depende de i2,..., in

q

pi2  pi3 …  pin i 31

in1

Obvio

q

=  [pi1 · logr(1/pi1)] · 1

Cada sumatoria es igual a 1.

= H(S)

Obvio

i11

Caso in: q



i11 q

q

…

= … i11 q

= …



[pi1 · pi2 · ... · pin ] · logr(1/pin)



pi1 · ... · pin-1 · [pin · logr(1/pin)]

in1 q

in1 q

q



i11 q

i ( n1)1 q

i11 q

i 21 q

i11

i 21 q

=  pi1 =  pi1

pi1 · ... · pin-1 q



pi2 …



pi2 …

= H(S) ·  pi1 i11

Obvio



pin-1



pin-1 · H(S)

i ( n1)1

q



pin · logr(1/pin)



i ( n1)1 q

i 21



in1 q

in1

pin · logr(1/pin)

Pues i1,...,in-1 no dependen de in Obvio Obvio

q

pi 2 …



i ( n1)1

pin-1

Obvio

= H(S) · 1 = H(S)

Cada sumatoria es igual a 1. Obvio

51

En una fuente con memoria o de Markov. Sea Fuente-M una fuente de Markov de orden m. Sea M la fuente afín. 1) Hr (M)  Hr ( M ) Demostración: Sea el estado αj = sj1 sj2 ... sjm Recordemos que:

qm

Hr (M) =  wj · Hr (S / sj1 sj2 ... sjm)

r-its

j 1

qm

=  wj · Hr (S / αj)

pues αj = sj1 sj2 ... sjm

j 1

qm

=  wj j 1

qm

q

q



p(si / αj) · logr (1/ p(si / αj))

i 1

definición de Hr (S / αj)

=



wj · p(si / αj) · logr (1/ p(si / αj))

wj ingresa a la sumatoria

=




conmutando las sumatorias

j 1 i 1 q qm

i 1

j 1

Aquí: wj = prob(αj) = prob(sj1 sj2 ... sjm) q

Por otro lado, Hr ( M ) =  prob(si) · logr (1/prob(si)) i 1

qm

qm

j 1

j 1

r-its

Donde prob(si) = pi =  p(si /αj) · wj =  wj · p(si /αj) q

qm

i 1 q

j 1

qm

i 1

j 1

Es decir, Hr ( M ) =  [ =





wj · p(si /αj) ] · logr (1/prob(si))

wj · p(si /αj) · logr (1/prob(si))

r-its

Entonces, Hr (M) - Hr ( M ) q

qm

i 1

j 1

=




q

qm

i 1

j 1

 

wj · p(si /αj) · logr (1/prob(si))

luego, 'juntando' las sumatorias

52

q

qm

i 1 q

j 1

= =

i 1 q

=



qm



j 1

qm



i 1 q

qm

i 1

j 1

=

j 1



[ wj · p(si / αj) · logr (1/ p(si/αj)) - wj · p(si /αj) · logr (1/prob(si)) ] wj · p(si /αj) · [ logr (1/ p(si/αj)) - logr (1/prob(si)) ]

factorizando wj · p(si /αj)

wj · p(si /αj) · logr [ (1/ p(si/αj)) / ( 1/prob(si) ) ]

log de un cociente

wj · p(si /αj) · logr [prob(si)/p(si/αj)]

medios con medios, etc.

q

qm

i 1 q

j 1

= [1/ln(r)] ·   [1/ln(r)] · 



qm



i 1 q

qm

i 1

j 1

= [1/ln(r)] · 

j 1



wj · p(si /αj) · ln[prob(si)/p(si/αj)]

pues logr(z)= ln(z)/ln(r)

wj · p(si /αj) · [prob(si)/p(si/αj) - 1]

pues ln(z)  z-1

[ wj · prob(si) - wj · p(si /αj) ]

distribuyendo wj · p(si

/αj) q

qm

i 1 q

j 1

= [1/ln(r)] · [ 



q

qm j 1

qm

i 1 q

j 1

i 1

j 1

wj · prob(si) -

= [1/ln(r)] · [  prob(si)  wj i 1 q

= [1/ln(r)] · [  prob(si) [ 1 ] i 1 q

-

 

qm

 

q

qm

i 1 q

j 1

 

qm

= [1/ln(r)] · [  prob(si)

-

 

= [1/ln(r)] · [  prob(si)

-



i 1 q i 1

wj · p(si /αj) ]

i 1 q i 1

j 1

wj · p(si /αj) ]

obvio prob(si) no depende de j

qm

wj · p(si /αj) ]

pues

wj · p(si /αj) ]

obvio

prob(si) ]

=0



j 1

cálculo de prob(si) obvio

Resumiendo, Hr (M) - Hr ( M )  0, es decir: Hr (M)  Hr ( M ) La entropía de la fuente afín (de memoria nula) M , de una Fuente-M (de Markov) siempre es mayor o igual que la entropía de la Fuente-M.

53

wj =1

L(C), LONGITUD MEDIA DE UN CÓDIGO Y CÓDIGO COMPACTO Sea una Fuente-S (de memoria nula). Sea C un código asociado a ella, se define la longitud media del código C así: q

L(C) =  pi · li i 1

Aunque no está prohibido usar L(C) para cualquier código es usual trabajar sólo con códigos no singulares (e incluso sólo con códigos unívocamente decodificables o instantáneos). Ejemplo: Fuente-S = ( {s1, s2, s3}, {1/3, 1/3, 1/3} ) C = {w1, w2, w3} = {1, 01, 001} Es claro que l1=1, l2=2, l3=3

con X={0,1}

3

Luego, L(C) =  pi · li = 1/3 · 1 + 1/3 · 2 + 1/3 · 3 = 1/3 · (1+2+3) =1/3 · 6 = 6/3 = 2 i 1

Nótese que cuando la Fuente-S es una fuente de memoria nula equiprobable, entonces: q

q

i 1

i 1

L(C) =  pi · li =  1/q · li = 1/q ·

q



i 1

li

Nótese que cuando el código C es bloque, entonces: q

q

q

i 1

i 1

i 1

L(C) =  pi · li =  pi · l = l ·  pi = l · 1 = l

Un código C unívocamente decodificable (o instantáneo) cuyo alfabeto código r-ario es X, asociado a una Fuente-S, se dice compacto cuando: L(C)  L(D) donde D es cualquier otro código r-ario unívocamente decodificable (o instantáneo) construido con el mismo alfabeto código r-ario X (obviamente con la misma cantidad de palabras código).

Para el ejempo anterior -en el que C es instantáneo- es claro que C no es compacto pues: D = {w1, w2, w3} = {1, 00, 01} con X={0,1} Es un código instantáneo tal que l1=1, l2=2, l3=2 3

Luego, L(D) =  pi · li = 1/3 · 1 + 1/3 · 2 + 1/3 · 2 = 1/3 · (1+2+2) =1/3 · 5 = 5/3 i 1

Obviamente 5/3 = L(D) < L(C) = 6/3

54

OTRAS PROPIEDADES DE LOS CÓDIGOS INSTANTÁNEOS COMPACTOS Sea C un código instantáneo compacto asociado a una Fuente-S. Si pi > pj entonces li  lj (recordemos que |wi| = li) Demostración: A partir de C, construyamos otro código C' intercambiando las palabras código asociadas al símbolo si y al símbolo sj (el resto de las palabras código se copian; la siguiente tabla clarifica esta construcción) S s1 ... si ... sj ... sq

pi p1 ... pi ... pj ... pq

Supongamos que li > lj L(C) - L(C') = L(C) - L(C')

C w1 ... wi ... wj ... wq

C' w'1 = w1 ... w'i = wj ... w'j = wi ... w'q = wq

=

p1 · l1 + ... + pi · li + ...+ pj · lj + ... + pq · lq - [ p1 · l1 + ... + pi · lj + ...+ pj · li + ... + pq · lq ]

pi · li + pj · lj - pi · lj - pj · li = pi · li - pi · lj + pj · lj - pj · li = pi · (li - lj) + pj · (lj - li) = pi · (li - lj) - pj · (li - lj) = (pi - pj) · (li - lj) > 0 =

Es decir, L(C) - L(C') > 0 Es decir, L(C) > L(C') Es decir, C no es compacto. Lo que es una contradicción. Ello muestra que nuestro supuesto es erróneo y que li  lj Un corolario obvio de este resultado es el siguiente: Sea C un código instantáneo compacto asociado a una Fuente-S. Si p1 > p2 > ... > pq-1 > pq entonces l1  l2  ...  lq-1  lq El siguiente contraejemplo muestra que el enunciado Si pi  pj entonces li  lj es falso S pi C s1 1/3 10 C es instantáneo y compacto s2 1/3 0 s3 1/3 11 p1  p2 pero l1 > l2 55

obvio reescribiendo factorizando obvio factorizando pi > pj, o sea (pi - pj) > 0 li > lj, o sea (li - lj) > 0

Sin embargo, el siguiente enunciado si es verdadero: Si C es un código instantáneo y compacto asociado a una Fuente-S Entonces  C' un código instantáneo y compacto asociado a la Fuente-S tal que cuando pi  pj se cumple que li  lj Demostración: Cuando pi > pj en la página anterior se muestra que li  lj, el resultado sigue con C' = C. En cambio, cuando pi = pj sólo existen dos posibilidades: a) Que li  lj en este caso el resultado sigue con C' = C b) Que li > lj en este caso construimos C' -a partir de C- intercambiando las palabras código asociadas al símbolo si y al símbolo sj (el resto de las palabras código se copian). Es claro que C' sigue siendo instantáneo (pues C lo es, y C' tiene las mismas palabras código de C). Veamos qué sucede con las longitudes medias de C y C': L(C) = p1 · l1 + ... + pi · li + ...+ pj · lj + ... + pq · lq L(C') = p1 · l1 + ... + pi · lj + ...+ pj · li + ... + pq · lq Dado que pi = pj, es evidente que L(C') = L(C), y como C es compacto es claro que C' es también compacto. Este resultado muestra que si C es un código instantáneo y compacto asociado a una Fuente-S, siempre es posible construir otro código instantáneo y compacto C' tal que Si p1  p2  ...  pq-1  pq entonces l1  l2  ...  lq-1  lq Sea la Fuente-S tal que p1  p2  ...  pq-1  pq > 0 Sea C un código instantáneo y compacto asociado a la Fuente-S en el cual se cumple que cuando p1  p2  ...  pq-1  pq sucede que l1  l2  ...  lq-1  lq (siempre es posible hacer que esto se cumpla, como lo muestra el anterior resultado) Entonces lq-1 = lq Demostración: Dado que pq-1  pq sucede que lq-1  lq. Supongamos que lq-1 < lq C es libre de prefijos, pues es instantáneo. wq es la palabra código más larga de C, |wq| = lq Es lícito suponer que wq = va ( 'a' un símbolo de X -el alfabeto código de C-; vX* ) Construyamos el código C' así: w'j = wj (j=1,...,q-1) w'q = v Ningún w'j = v, lo que haría a C' singular, pues C es libre de prefijos. Es decir, C' aún es instantáneo. Pero L(C') - L(C) = p1 · l1 + ... + pi · li + ...+ pj · lj + ... + pq · (lq - 1) - [p1 · l1 + ... + pi · li + ...+ pj · lj + ... + pq · lq] = pq · (lq - 1) - pq · lq = pq · lq - pq - pq · lq = - pq < 0 pues pq > 0 Es decir, L(C') < L(C). Es decir, C no es compacto (pero C sí es compacto). Contradicción que muestra lo erróneo del supuesto y que lq-1 = lq 56

Sea X={a,a'} el alfabeto código de un código binario C (por ej. a=0, a'=1). Se dice que dos palabras código wi,wj son mellizas cuando wi=va y wj=va' Es decir, cuando difieren en el último símbolo (bit). Sea la Fuente-S tal que p1  p2  ...  pq-1  pq > 0 Sea C un código binario instantáneo y compacto asociado a la Fuente-S Entonces  C' un código instantáneo y compacto tal que sus dos palabras código más largas (las dos últimas palabras código) son mellizas. Demostración: Los anteriores resultados muestran que -a partir de C- se puede construir un código tal que cuando p1  p2  ...  pq-1  pq sucede que l1  l2  ...  lq-1  lq De manera que, sin pérdida de generalidad, se puede suponer que C ya es así. C es libre de prefijos, pues es instantáneo. wq es la palabra código más larga de C, |wq| = lq Es lícito suponer que wq = va Lógicamente existen dos alternativas: a) va'  C b) va'  C Mostraremos primero que el inciso b) es imposible: Supongamos que va'  C Construyamos el código C' así: w'j = wj (j=1,...,q-1) w'q = v Ningún w'j = v, lo que haría a C' singular, pues C es libre de prefijos. Y, dado que va'  C, w'q=v no es prefijo de ninguna palabra código de C, es decir, C' aún es instantáneo. Un razonamiento idéntico al de la demostración anterior muestra que L(C')
57

RELACIONES ENTRE Hr(S) y L(C) Si C es un código r-ario unívocamente decodificable (instantáneo) asociado a la Fuente-S Entonces Hr(S)  L(C) Demostración: q

q

Hr(S) - L(C) =  pi · logr(1/pi) -



pi · li

=  pi · logr(1/pi) -



pi · logr(r li )

i 1 q i 1 q

i 1 q i 1

exponencial y log son inversas

=  [ pi · logr(1/pi) - pi · logr(r li ) ]

'uniendo' las sumatorias

=  pi · [ logr(1/pi) - logr(r li ) ]

factorizando pi

=  pi · logr(1/pi / r li )

log(a/b) = log a - log b

=  pi · logr(1 / (pi · r li ) )


i 1 q i 1 q i 1 q i 1

q

= [1/ln(r)] ·  pi · ln(1 / (pi · r li ) )

pues logr(z)=

i 1

ln(z)/ln(r) q

 [1/ln(r)] ·  pi · [1 / (pi · r li ) - 1] i 1 q

pues ln(z)  z-1

= [1/ln(r)] ·  [ 1 / r li - pi ] i 1 q

distribuyendo pi

q

= [1/ln(r)] · [  1/r li -



pi ]

introduciendo la sumatoria

= [1/ln(r)] · [  r – l i -



pi ]

obvio

]

obvio

i 1 q i 1 q

= [1/ln(r)] · [  r – l i i 1

i 1 q

i 1

1

0 q

Pues



i 1

r – l i  1 ya que como C es unívocamente decodificable (o instantáneo) el

teorema de McMillan (o Kraft) garantiza esto. Así pues Hr(S) - L(C)  0, es decir: Hr(S)  L(C). La igualdad se da cuando [1 / (pi · r li)] = 1 y

q



i 1

r – l i = 1. Pero cuando pi = r – l i,

despejando li se verifica la igualdad cuando li=logr(1/pi), pues la segunda condición q



i 1

q

r – l i =  pi =1 se cumple siempre. Para tener sentido logr(1/pi) debe ser un entero. i 1

58

Eficiencia y redundancia de un código unívocamente decodificable (o instantáneo) C) La eficiencia de C se define como  = [ Hr(S) / L(C) ] La redundancia de C se define como ' = [1-]

[x 100%] [x 100%]

Es obvio, por el anterior resultado, que 01 y que 0'1 La eficiencia de C será máxima cuando L(C)= Hr(S), que como vimos sólo sucede cuando li=logr(1/pi) [con logr(1/pi) entero]. O, lo que es lo mismo cuando pi = r – l i =( 1/ r l i )=(1/r)l i [para enteros li]. A las Fuentes-S que cumplen esta característica algunos las llaman especiales. Ej.: Fuente-S=({ s1 , s2 , s3 },{1/2, 1/4, 1/4}) C={0,10,11} X={0,1} r=2 Sea la fuente de memoria nula Fuente-S. Entonces  C un código r-ario unívocamente decodificable (ó instantáneo) asociado a la Fuente-S tal que Hr(S)  L(C) < Hr(S) + 1 Demostración: Por el anterior resultado sabemos que, para cualquier código D r-ario unívocamente decodificable (ó instantáneo), Hr(S)=L(D) cuando li=logr(1/pi) , con logr(1/pi) un entero. Este mejor caso sólo es posible en fuentes especiales. Sin embargo, dada la Fuente-S, podemos construir el código C empezando por definir sus longitudes lo más cercanas posibles al mejor caso , así: li=techo[logr(1/pi)], es decir, li es el único entero tal que logr(1/pi)  li < logr(1/pi) + 1 Elegidas las longitudes li de esta manera es obvio que se cumple: logr(1/pi)  li Por lo tanto -despejando pi- se cumple: pi  r – l i, o lo que es lo mismo, r – l i  pi Así pues: r – l 1  p1 ... r – l q  pq Sumando los lados izquierdos (y derechos) en las desigualdades (preservando el sentido ) q



i 1

r –li 

q



i 1

q

pi = 1, es decir,



i 1

r –li  1

Por lo tanto, el teorema de McMillan (Kraft) nos asegura que con las longitudes así elegidas existe un código C r-ario unívocamente decodificable (instantáneo). Podemos seguir construyendo este código C utilizando árboles, la segunda versión del teorema de Kraft o cualquier otro mecanismo. Concentrémonos sin embargo en logr(1/pi)  li < logr(1/pi) + 1 multiplicando cada miembro por pi resulta pi · logr(1/pi)  pi · li < pi · logr(1/pi) + pi · 1 Así pues: p1 · logr(1/p1)  p1 · l1 < p1 · logr(1/p1) + p1 · 1 ... pq · logr(1/pq)  pq · lq < pq · logr(1/pq) + pq · 1

59

Sumando uno a uno los miembros en las desigualdades, resulta: q



i 1

pi · logr(1/pi) 

q



i 1

pi · li <

q



i 1

q

pi · logr(1/pi) +

Que no es otra cosa que. Hr(S)  L(C) < Hr(S) Que es lo que queríamos demostrar.

+



i 1

pi · 1

1

Sea D un código r-ario compacto unívocamente decodificable (instantáneo) asociado a una Fuente-S, entonces Hr(S)  L(D) < Hr(S)+1 Demostración: 1) Sea C el código del anterior resultado, por tanto: Hr(S)  L(C) < Hr(S) + 1, es decir, 2) L(C) < Hr(S) + 1 3) Dado que D es compacto entonces L(D)  L(C) 4) Además sabemos que Hr(S)  L(D) 5) De 3 y 4: Hr(S)  L(D)  L(C) 6) De 2 y 5: Hr(S)  L(D)  L(C) < Hr(S) + 1 Es decir, Hr(S)  L(D) < Hr(S) + 1

60

EL PRIMER TEOREMA DE SHANNON TEOREMA DE LA CODIFICACIÓN SIN RUIDO Sea Fuente-S una fuente de memoria nula. Y llamemos a su extensión n-ésima Fuente-Sn. Sea Dn un código compacto r-ario unívocamente decodificable (instantáneo) de dicha extensión, con L(Dn) como su longitud media Entonces es posible codificar la Fuente-S con un código cuya longitud media sea arbitrariamente cercana a su entropía Hr(S). Demostración: Por el anterior resultado sabemos que: Hr(Sn)  L(Dn) < Hr(Sn) + 1 n·Hr(S)  L(Dn) < n·Hr(S) + 1 Hr(S)  L(Dn)/n < Hr(S) + 1/n

dado que Hr(Sn) = n·Hr(S), resulta: multiplicando cada miembro por 1/n resulta: Luego: n lim L(D )/n = Hr(S) n   El resultado sigue si tomamos L(Dn)/n como la longitud media de un esquema de codificación de la Fuente-S (basado en la codificación de su extensión n-ésima). Estrictamente hablando, al codificar la Fuente-Sn no se codifica la Fuente-S, puesto que no se asignan palabras código a los símbolos de S, pero la codificación de la Fuente-Sn nos permite codificar la información que viene de S, puesto que cada palabra código en Dn representa un bloque de n símbolos de S y así -en promedio- cada elemento de S requiere L(Dn)/n símbolos r-arios para su codificación (a eso nos referimos con un esquema de codificación de la Fuente-S) En la práctica, la persecución del límite Hr(S), consiste precisamente en codificar la Fuente-Sn. Lo de malo es que al hacerlo así, debemos codificar grupos de n-símbolos de la fuente original (en vez de símbolos sólos), lo que implica mayor complejidad.

61

CONSTRUCCIÓN DE UN CÓDIGO C PARA UNA FUENTE-S Dada una Fuente-S, se requiere un procedimiento para construir un código r-ario C asociado a ella. Es deseable que C sea -en orden de importancia creciente-: no singular, unívocamente decodificable, instantáneo y compacto. Para construir dicho código C, además de la intuición, describiremos otros modos de hacerlo; tales modos y el código resultante recibirán el mismo nombre (usualmente el de su proponente). Códigos de Shannon.Aquí, dada la Fuente-S, sólo se ofrecen las longitudes de las palabras código de C. Al demostrar que Hr(S)  L(C) < Hr(S) + 1, hemos utilizado: li=techo[logr(1/pi)] Ya vimos que el teorema de McMillan (Kraft) nos asegura que con las longitudes así elegidas existe un código C r-ario unívocamente decodificable (instantáneo). Ejemplo: Sea una Fuente-S la Fuente-S=({s1,s2,s3,s4,s5},{3/10,1/5,1/5,1/5,1/10}) r=2 l1 = techo[log2(10/3)] = techo[log2(3.3333333)] = techo[1.736965] = 2. El resto de los li se halla de manera semejante: l2=3, l3=3, l4=3, l5=4. Luego, sólo resta construir C con dichas longitudes (para ello podemos apelar a los árboles, la segunda versión del teorema de Kraft o cualquier otro mecanismo). Códigos de Fano.Sea la Fuente-S=({s1, ... ,sq},{p1, ... ,pq}) donde prob(si)=pi Se construye un árbol r-ario donde el nodo raíz incluye todos los símbolos (cuyas probabilidades suman 1). Cada siguiente nivel del árbol se expande así: Cada nodo (padre) tiene r nodos hijo, estos r nodos deben ser equiprobables (o casi equiprobables). Es decir, los símbolos de cada nodo (padre) se reagrupan en r subgrupos (r nodos hijo) equiprobables (o casi equiprobables). Si en algún nivel un nodo tiene menos de r símbolos (es decir, no puede subdividirse en r nodos), se acepta excepcionalmente el número de nodos hijo (menor a r) que pueda tener. Si en algún nivel un nodo tiene un sólo símbolo, se detiene su crecimiento. Finalmente, cuando todos los nodos hoja tienen un sólo símbolo: Se etiquetan los hijos de cada nodo padre con los símbolos r-arios del alfabeto código (no es necesario hacerlo en orden, pero se sugiere ello para homogeneizar los resultados): Las palabras código de C resultan de concatenar dichos símbolos para cada camino entre el nodo raíz y cada nodo hoja (palabra código que se la asigna al símbolo de la Fuente-S que corresponde a dicho nodo hoja). Ejemplo:

r=3; X={0,1,2}; C={0,1,20,21} 62

Para ciertas fuentes, puede existir más de una alternativa lícita de subdivisión en algún nivel del árbol. Lo que da lugar a uno u otro código. Eso se observa en el siguiente ejemplo (del libro de Togneri), que también sirve para mostrar que un código de Fano, si bien es instantáneo no necesariamente es compacto.

C = { 00, 01, 100, 101, 110, 111} con L(C) = 22/9

En cambio:

C = { 0, 1000, 1001, 101, 110, 111 } con L(C) = 21/9

(este código es compacto)

Dividiremos la presentación de los códigos de Huffman en binarios y r-arios (r>2) 63

Códigos de Huffman binarios.Supondremos que el alfabeto (del) código es X={0,1} Sea Sj-1 una fuente de memoria nula (cuyos símbolos tienen sus probabilidades ordenadas en forma decreciente). Sean s0 y s1 los dos símbolos con menor probabilidad. Sean prob(s0)=p0 y prob(s1)=p1 Fuente reducida.- Denominaremos fuente reducida (de Sj-1) a la fuente de memoria nula Sj construida a partir de Sj-1 así: Todos los símbolos -excepto s0 y s1- se copian con sus respectivas probabilidades. s0 y s1 se agrupan en un único símbolo denominado s con prob(s) = p = p0 + p1 Los símbolos de Sj (y sus probabilidades) se (re)ordenan en forma decreciente de acuerdo a dichas probabilidades. Es claro que la fuente reducida (Sj) tiene un símbolo menos que la fuente original (Sj-1). Ejemplo (no se fije en el código Cj que le añadimos a la fuente Sj): Sj-1 prob Sj prob Cj s1 6/13 s1 6/13 0 p = p0 + p1 = 2/13 + 2/13 = 4/13 s2 3/13 4/13 10 s 2/13 s2 3/13 11 s0 2/13 s1 Construcción de un código para la fuente Sj-1 .Sea Sj la fuente reducida de Sj-1 Sea Cj un código para Sj Sea w la palabra código de s Construimos el código Cj-1 -para la fuente Sj-1- a partir del código Cj así: Se copian las palabras código de todos los símbolos de Sj -excepto s(con cuidado pues los símbolos no siempre están a la misma altura) Las palabras código de s0 y s1 son w·0 y w·1 respectivamente. Ejemplo: Sj-1 prob Cj-1 Sj prob Cj s1 6/13 0 s1 6/13 0 s2 3/13 11 4/13 10 s 2/13 100 s 3/13 11 s0 2 2/13 101 s1 El principal resultado de Huffman, además de la esquemática forma de hallar sus códigos, es el siguiente: Sea Sj la fuente reducida de Sj-1 Sea Cj-1 (un código para Sj-1) construido a partir de Cj (un código para Sj) como se indicó. Si Cj es compacto entonces Cj-1 es compacto Demostración: Supongamos que Cj-1 no es compacto. Sea el código compacto Dj-1 (para Sj-1), luego: a) L(Dj-1) < L(Cj-1) En la página 57 se muestra que es lícito suponer que las dos palabras código más largas de Dj-1 (correspondientes a s0 y s1) son mellizas, designémoslas como v0=v0 y v1=v1.

64

De manera "inversa" a como se indicó antes, pero lícitamente y para efectos de demostración, podemos construir -a partir de Dj-1- un otro código Dj (para Sj) así: Se copian todas las palabras código de Dj-1 en Dj -excepto las de los símbolos s0 y s1La palabra código de s es v=v (resulta de suprimir el último símbolo en v0 -ó v1-). Sj-1 pi Dj-1 Cj-1 Sj pi Dj Cj s1 p1 v1 w1 s1 p1 v1 w1 s2 p2 v2 w2 s2 p2 v2 w2 ... ... ... ... ... ... ... ... v s0 p0 v0=v0 w0 s p w s1 p1 v1=v1 w1 Pero entonces: Por la forma de construir Cj-1 a partir de Cj (según lo indicado antes), y Por la forma de construir Dj a partir de Dj-1 (según la forma "inversa" recién indicada) Resulta: b) L(Cj-1) - L(Cj) = p1·|w1| + p2·|w2| + ... + p0·|w0| + p1·|w1| - [ p1·|w1| + p2·|w2| + ... + p·|w| ] = p0·|w0| + p1·|w1| - p·|w| obvio = p0·(|w|+1) + p1·(|w| +1) - p·|w| pues |wc|=|w|+1 = p0·|w| + p0 + p1·|w| + p1 - p·|w| obvio = p0·|w| + p0 + p1·|w| + p1 - (p0+p1)·|w| pues p=p0+p1 = p0 + p1 = p obvio Luego L(Cj-1) = p + L(Cj) c) L(Dj-1) - L(Dj) = p1·|v1| + p2·|v2| + ... + p0·|v0| + p1·|v1| - [ p1·|v1| + p2·|v2| + ... + p·|v| ] = p0·|v0| + p1·|v1| - p·|v| = p0·(|v|+1) + p1·(|v| +1) - p·|v| = p0·|v| + p0 + p1·|v| + p1 - p·|v| = p0·|v| + p0 + p1·|v| + p1 - (p0+p1)·|v| = p0 + p1 = p Luego L(Dj-1) = p + L(Dj)

obvio pues |vc|=|v|+1 obvio pues p=p0+p1 obvio

Substituyendo b) y c) en a) tenemos: p + L(Dj) < p + L(Cj), es decir, L(Dj) < L(Cj) Luego Cj no es compacto. Lo que contradice que Cj sea compacto. Esto nos permite concluir que nuestro supuesto es erróneo y que Cj-1 sí es compacto. Otro resultado (inmediato por simple inspección) es el siguiente: Si Cj es instantáneo (libre de prefijos) entonces Cj-1 es instantáneo (libre de prefijos) La construcción de un código de Huffman binario para una Fuente-S es como sigue: Llamemos S1 a la Fuente-S original. 1) Hacer reducciones sucesivas S2, S3, ... , Sq-1 Nótese que Sq-1 tiene sólo dos símbolos 2) Construir el código Cq-1 = {0,1} para Sq-1 3) Construir sucesivamente -como se indica arriba- los códigos Cq-1, Cq-2, ... , C2, C1 C = C1 es el código de Huffman para la Fuente-S original.

65

Ejemplo (se omiten los nombres de los símbolos si y en su lugar están las probabilidades):

Para la fuente Sq-1 de dos símbolos, su código binario asociado Cq-1={0,1} es -por simple inspección- instantáneo y compacto. Se concluye, por los resultados anteriores al ejemplo, que los códigos de Huffman son instantáneos y compactos.

Códigos de Huffman r-arios (r > 2).Supondremos que el alfabeto (del) código es X={ 0, ... , r-1 } La construcción de un código de Huffman r-ario para una Fuente-S es semejante a la construcción de un código binario con las siguientes modificaciones: 1) Las reducciones agrupan en un único símbolo denominado s a los r símbolos con menor probabilidad, prob(s) = prob(s0) + ... + prob(s(r-1)) = p0 + ... + p(r-1) = p 2) Sea w la palabra código de s (en Cj) Las palabras código de s0, ... , s(r-1) son w·0, ... , w·(r-1) respectivamente (todas las otras se copian). Sin embargo, el número inicial de símbolos de S1 (S= S1 es la fuente original) debe satisfacer el hecho siguiente: Que sus sucesivas reducciones sean tales que la última fuente reducida tenga exactamente r símbolos (que es como funciona el método), Ejemplo (de mal uso del método, cuando lo anterior no se cumple): X={0,1,2} S 1/4 1/4 1/4 1/4

(r = 3) C 1 00 01 02

S2 3/4 1/4

C2 0 1

L(C) = 7/4 Enseguida hallaremos otro código ¡con menor longitud media!

Por ello puede ser necesario agregar símbolos vacuos (o espúreos, o fantasma) con probabilidad 0. El nuevo número total de símbolos debe ser: q' = r + techo[ (q-r) / (r-1) ] · (r-1) Es claro que se deben agregar (q' - q) símbolos vacuos.

66

Ejemplo: Para la misma Fuente-S anterior. q' = 3 + techo[ (4-3) / (3-1) ] · (3-1) = 3 + techo[1/2] · 2 = 3 + 1· 2 = 5 Se agregan (q' - q) = (5 - 4) = 1 nuevo símbolo vacuo. (Se omiten los nombres de los símbolos si y en su lugar están las probabilidades):

Cuyo L(C) = 6/4

Ejemplo: X={0,1,2,3} (r = 4) (Se omiten los nombres de los símbolos si y en su lugar están las probabilidades):

67

CODIFICACIÓN ARITMÉTICA Una otra manera muy diferente pero eficiente de codificar secuencias de símbolos "si1...sim" de la Fuente-S sin construir un código C -basada en el trabajo inicial de Elias y posterior de Witten- es como sigue. Codificación.- La idea es (calcular y) asignar un subintérvalo ( del intérvalo [0,1[ ) al mensaje "si1...sim" que se quiere codificar (el tamaño del subintérvalo es igual a la probabilidad prob(si1...sim) de dicho mensaje). 1) Sea [I,D[ = [0,1[ el intérvalo inicial con sus límites Izquierdo y Derecho. Sea j = 0 2) Se divide el segmento [I,D[ en q subintérvalos, proporcionales (y correspondientes) -según su probabilidad- a cada uno de los símbolos s1,...,sq. 3) j = j+1 Se trabaja con el subíntervalo correspondiente a sij. Se actualizan los valores [I,D[ para que correspondan a dicho subintérvalo Ir a 2 (a no ser que j=m, en cuyo caso [I,D[ es el subintérvalo buscado) 4) Se codifica el mensaje "si1...sim" con cualquier valor dentro de este subintérvalo. Ejemplo: Sea la Fuente-S=({s1, s2, s3}, {0.7, 0.2, 0.1}) q=3 Sea el mensaje "si1...sim" = "si1si2si3" = "s2s3s3". 1) [I,D[ = [0,1[ j=0 2) Subdividimos el segmento [0,1[ en q=3 subintérvalos así: [0 -------------- 0.7 ---- 0.9 -- 1[ 3) j=1 Trabajamos con el subintérvalo que corresponde a si1=s2, es decir, [0.7,0.9[ Ir a 2 con [I,D[ = [0.7,0.9[ 2) Subdividimos el segmento [0.7,0.9[ en q=3 subintérvalos así: [0.7 -------------- 0.84 ---- 0.88 -- 0.9[ 3) j=2 Trabajamos con el subintérvalo que corresponde a si2=s3, es decir, [0.88,0.9[ Ir a 2 con [I,D[ = [0.88,0.9[ 2) Subdividimos el segmento [0.88,0.9[ en q=3 subintérvalos así: [0.88 -------------- 0.894 ---- 0.898 -- 0.9[ 3) j=3 Trabajamos con el subintérvalo que corresponde a si3=s3, es decir, [0.898,0.9[ Como j=m=3 [I,D[ = [0.898,0.9[ es el subintérvalo buscado 4) Cualquier valor dentro de este subintérvalo codifica el mensaje, por ej. 0.8985 No es necesario 'dibujar' los segmentos y pueden hacerse los cálculos para hallar el siguiente subintérvalo de manera más algorítmica. Para ello hay diversas presentaciones. Esta es la nuestra:

68

Lj representa la longitud del intérvalo que se está considerando. Ij es su límite izquierdo. Dj es su límite derecho. El mensaje a codificar es "si1...sim". Las probabilidades de cada símbolo son pi1, ..., pim (pij como referencia general). Las probabilidades acumuladas de cada símbolo son Acumi1, ..., Acumim (Acumij como referencia general). j=0 I0=0 D0=1 L0=D0 - I0=1 Para j=1 hasta m Lj = Lj-1 · pij Dj = Ij-1 + Lj-1 · Acumij Ij = Dj - Lj Siguiente j El intérvalo [Im,Dm[ es el buscado. Cualquier valor dentro de este subintérvalo codifica el mensaje Ejemplo: Sea el mensaje "si1...sim" = "si1si2si3" = "s2s3s3" S pij Acumij s1 0.7 0.7 s2 0.2 0.9 s3 0.1 1

m=3

j Ij Lj Dj 0 0 1 1 1 0.7 0.2 0.9 2 0.88 0.02 0.9 3 0.898 0.002 0.9 Cualquier valor dentro del intérvalo [0.898,0.9[ codifica el mensaje, por ej. 0.8985 Decodificación.- El proceso de decodificación es esencialmente el mismo. Parte de un número real recepcionado, y se van obteniendo los subintérvalos sucesivamente, tomando en cuenta -en cada subdivisión- los que contengan al número real que se recibe. Sin embargo, el siguiente ejemplo muestra un pequeño gran detalle que falta considerar. Ejemplo: Sea la Fuente-S=({s1, s2}, {0.5, 0.5}) Sea 0 el número real que se recibe. Subdividimos el segmento [0,1[ en q=2 subintérvalos así: [0 ----- 0.5 ------ 1[ Es claro que 0 está en el primer subintérvalo, luego el primer símbolo es "s1" Subdividimos el segmento [0,0.5[ en q=2 subintérvalos así: [0 ---- 0.25 ---- 0.5[ Es claro que 0 está en el primer subintérvalo, luego el segundo símbolo es "s1" Subdividimos el segmento [0,0.25[ en q=2 subintérvalos así: [0 --- 0.125 --- 0.25[ Es claro que 0 está en el primer subintérvalo, luego el tercer símbolo es "s1" ... Ya se habrá dado cuenta que falta considerar cuándo nos detenemos. Una alternativa es considerar un tamaño de bloque fijo en el envío de símbolos. Otra es enviar, previamente al mensaje, la longitud de éste. Otra alternativa -que adoptamos- es considerar en nuestra fuente un símbolo que funja como fin de mensaje. Al codificar se lo coloca una única vez al final del mensaje. Al decodificar, nos detenemos cuando lo encontremos. 69

Con esta convención, el procedimiento tiene diversas presentaciones. Esta es la nuestra: Lj representa la longitud del intérvalo que se está considerando. Ij es su límite izquierdo. Dj es su límite derecho. El número real que se recibe es num. Las probabilidades de cada símbolo son pi1, ..., pim (pij como referencia general). Las probabilidades acumuladas de cada símbolo son Acumi1, ..., Acumim (Acumij como referencia general). Sea Acum0=0 I=0 D=1 L= D - I =1 Repetir val = ( num - I ) / L j=0; Repetir j=j+1 Hasta val  [Acumj-1, Acumj[ El siguiente símbolo decodificado es sj D = I + L · Acumj L = L · pj I= D- L Hasta que se haya decodificado el último símbolo del mensaje Ejemplo: J S pj Acumj 0 0 1 s1 0.7 0.7 2 s2 0.2 0.9 3 s3 0.1 1 El número real que se recibe es num=0.8985 val j I L

0.8985 0.9925

2 3

0 0.7 0.88

1 0.2 0.02

D 1 0.9 0.9

símbolo decodificado s2 s3

val [0.7, 0.9[ val [0.9, 1[

Si tomamos s3 como marca de fin de mensaje, hemos terminado con m="s2s3" Es común que el último símbolo, con una probabilidad muy baja, sea dicha marca. Haremos una fila más, sólo por gusto teórico y para estar a tono con el primer ejemplo. 0.925 3 0.898 0.002 0.9 s3 El mensaje es m="s2s3s3" Consideraciones importantes: 1) Sea [Im,Dm[ el intérvalo calculado para codificar el mensaje, si bien cualquier valor dentro de él sirve, es obvio que preferimos uno con una parte fraccionaria corta. Por ejemplo, si [Im,Dm[ = [0.69432178,0.709558254[ podemos tomar num=0.7 2) Al utilizar codificación aritmética receptor y emisor saben que se trabaja con un número dentro de [0,1[; así pues podemos prescindir del "0." y considerar únicamente la parte fraccionaria: en vez de trabajar con 0.8985 podemos trabajar con 8985 solamente. El emisor no envía "0." y el receptor agrega "0." 3) Los anteriores puntos también son válidos si, de acuerdo al código r-ario que estemos utilizando, convertimos num -e incluso [Im,Dm[- a números en base r (es decir, binarios, etc.) 70

CANALES DE INFORMACIÓN CON RUIDO Hasta ahora hemos considerado la codificación como si no existieran errores: lo que codifica el emisor, es lo que decodifica el receptor. Emisor Receptor envía c --->--->---> se transmite --->--->---> recibe c sin errores ( c es la codificación (lo decodifica) del mensaje m) Así, suponemos que el canal de información es silencioso, sin ruido o sin errores: exactamente lo que se envía (desde el emisor), se recibe (por el receptor). Ahora nos detendremos a analizar los canales que tienen interferencia, que incluyen la posibilidad de error, que tergiversan los símbolos que atraviesan por él, es decir: los canales con ruido (o ruidosos). Por ej.: se envía se recibe 0101 ---->---> se transmite ---> ---> 0100 (¡con errores!) interferencia (ruido) En principio describiremos estos canales y luego calcularemos cuánta información puede perderse (tergiversarse) -en promedio- junto a otras cantidades. Definición de canal con ruido.- Un canal con ruido (cr) se define como cr = (A,P,B) donde: A={ a1, ... ,ar } es el alfabeto de entrada (al canal) [los símbolos que se envían] B={ b1, ... ,bs } es el alfabeto de salida (del canal) [los símbolos que se reciben] P es el conjunto de probabilidades del canal del tipo p(bj/ai) se presenta generalmente como listado o como matriz (las probabilidades también pueden ir como arcos en el 'grafo del canal') p(bj/ai) representa la probabilidad de recibir el símbolo bj dado que se envía el símbolo ai Un canal está totalmente definido si junto a P se establecen las probabilidades de entrada p(ai) para i=1,...,r Junto a las probabilidades p(ai) un canal de información con ruido se puede presentar así:

Y la matriz P así:

71

salidas e n t r a d a s

P=

b1 b2 a1 p(b1/a1) p(b2/a1) a2 p(b1/a2) p(b2/a2) ... ... ... . . ... ... ... ar-1 p(b1/ar-1) p(b2/ar-1) ar p(b1/ar) p(b2/ar)

... ... ...

... ... ...

bs-1 p(bs-1/a1) p(bs-1/a2) ...

bs p(bs/a1) p(bs/a2) ...

... p(bs-1/ar-1) p(bs-1/ar)

... p(bs/ar-1) p(bs/ar)

p(bj/ai) ... ...

... ...

Es común pensar que r=s (y que bk=ak para k=1,...,r) Sin embargo, r puede ser diferente de s (de hecho nuestra definición de canal con ruido es tan genérica que permite trabajar con esta posibilidad). Un ejemplo clásico -que ampliaremos luego- es considerar A = {a1,a2} = {0,1} se ingresan al canal ceros y/o unos (por ej. 0101) B = {b1,b2,b3} = {0,1,?} salen del canal ceros y/o unos y/o signos ilegibles (ej. 01?1) con r = 2, s = 3, y obviamente r  s Ejemplo: Sea el canal cr=(A,P,B) A = {a1,a2} B = {b1,b2,b3} P=

b1 1/2 1/3

a1 a2

P en forma de listado: p(b1/a1)=1/2 p(b2/a1)=0 p(b1/a2)=1/3 p(b2/a2)=1/3

p(a1)=1/2 b2 0 1/3

p(a2)=1/2

b3 1/2 1/3

p(b3/a1)=1/2 p(b3/a2)=1/3

Como mencionamos antes, puede presentarse un 'grafo del canal' así: a1

1/2

1/2

b1 1/3

b2 1/3

a2

1/3

b3

En los canales con ruido se considera que, enviado un símbolo de entrada ai, se recibe -necesariamente- algún símbolo de salida bj. Esto es, dado que se envía el símbolo ai: s



j1

p(bj/ai) = p(b1/ai) + ... + p(bs/ai) = 1

Esto se refleja en la matriz P en que cada fila debe sumar 1.

72

Probabilidad conjunta.- Se sabe que p(ai,bj) = p(bj/ai) · p(ai) = p(ai/bj) · p(bj) Cálculo de p(bj).- Dado un canal totalmente definido, p(bj) se obtiene así: r

r

i 1

i 1

p(bj) =  p(bj/ai) · p(ai) =  p(ai,bj) Probabilidades hacia adelante y hacia atrás.La probabilidades p(bj/ai) se conocen como probabilidades hacia adelante. Representan la probabilidad de recibir el símbolo bj dado que se envía el símbolo ai. Por el teorema de Bayes, dados p(bj/ai) y p(ai): p(ai/bj) = p(ai,bj) / p(bj) = [ p(bj/ai) · p(ai) ] / p(bj) La probabilidades p(ai/bj) se conocen como probabilidades hacia atrás. Representan la probabilidad de haber enviado el símbolo ai dado que se recibe bj. Sistema de entropías.- Se definen así: Entropía de la entrada ó entropía a priori de A:

Entropía de la salida: s

r

H(A) =  p(ai) · log[1/p(ai)]

H(B) =  p(bj) · log[1/p(bj)]

Entropía a posteriori de A dado bj:

Entropía condicional de B dado ai

j1

i 1

r

s

H(A/bj) =  p(ai/bj) · log[1/p(ai/bj)]

H(B/ai) =  p(bj/ai) · log[1/p(bj/ai)]

Equivocación de A con respecto a B ó equivocación del canal:

Equivocación de B con respecto a A

H(A/B)

H(B/A)

i 1

j1

s

r

=  p(bj) · H(A/bj) j1 s

=  p(ai) · H(B/ai) i 1 r

r

j1 s

s

=  p(ai) ·  p(bj/ai) · log[1/p(bj/ai)]

=  p(bj) ·  p(ai/bj) · log[1/p(ai/bj)]

i 1 r

i 1

r

j1

s

=



p(bj) · p(ai/bj) · log[1/p(ai/bj)]

=



p(ai) · p(bj/ai) · log[1/p(bj/ai)]

=



p(ai,bj) · log[1/p(ai/bj)]

=



p(ai,bj) · log[1/p(bj/ai)]

j1 s

j1

i 1 r i 1

i 1 r i 1

j1 s j1

Información mutua entre B y A

Información mutua entre A y B I(A;B) = H(A) - H(A/B)

I(B;A) = H(B) - H(B/A) Entropía conjunta: r

H(A,B) = 

i 1

s



j1

p(ai,bj) · log[1/p(ai,bj)]

73

Hemos resaltado la equivocación del canal H(A/B) y la información mutua entre A y B I(A;B) por sus enriquecidas interpretaciones: H(A/B) puede interpretarse como la cantidad de información sobre A que no deja pasar el canal (la pérdida media de información sobre A causada por el canal). I(A;B) puede interpretarse como la cantidad de información sobre A que atraviesa el canal (que el canal deja pasar). Ejemplo (todo se calcula en bits): Sea el canal cr=(A,P,B) A = {a1,a2} B = {b1,b2,b3} P=

a1 a2

b1 1/2 1/3

b2 0 1/3

b3 1/2 1/3

p(a1) = 1/2 p(a2) = 1/2 H(A) = 1 bit p(b1) = 5/12 p(b2) = 2/12 H(B) = 1.4834 bits

p(b3) = 5/12

H(A/B) = 0.80912549537889 H(B/A) = 1.29248125036058 H(A,B) = 2.29248125036058 I(A;B) = 0.19087450462111

bits bits bits bits

74

LA INFORMACIÓN MUTUA NO ES NEGATIVA I(A;B)  0 Demostración: Por definición I(A;B) = H(A) - H(A/B) 1) r

H(A) =  p(ai) · log[1/p(ai)] i 1 r

=  p(ai) · log[1/p(ai)] · 1

obvio

i 1 r

s

=  p(ai) · log[1/p(ai)] · [  p(bj/ai)] i 1 r

j1

s

pues



j1

p(bj/ai) = 1

s

=



p(ai) · log[1/p(ai)] · p(bj/ai)


=



p(bj/ai) · p(ai) · log[1/p(ai)]

conmutatividad

=



p(ai,bj) · log[1/p(ai)]

pues p(bj/ai) · p(ai) = p(ai,bj)

i 1 r

i 1 r i 1

j1 s j1 s

j1

2) Ya vimos que: s

r

H(A/B) = 




=




j1 r

i 1

i 1 s

j1


De 1 y 2: I(A;B) = H(A) - H(A/B) r

s

r

s

i 1

j1

=




=



{ p(ai,bj) · log[1/p(ai)] - p(ai,bj) · log[1/p(ai/bj)] }

propiedades de

i 1 r i 1

j1 s j1

-

 


sumatoria r

s

=



p(ai,bj) · { log[1/p(ai)] - log[1/p(ai/bj)] }

factorizando p(ai,bj)

=



p(ai,bj) · log[ 1/p(ai) / 1/p(ai/bj)]

log a - log b=log a/b

i 1 r i 1

j1 s

j1

75

r

=

i 1

s



j1 r s

p(ai,bj) · log[p(ai/bj) / p(ai)]


=

 

p(ai,bj) · log[p(ai) / p(ai/bj)]-1

propiedades de exponente

=-

 

p(ai,bj) · log[p(ai) / p(ai/bj)]

propiedades de logaritmo

=-

 

p(ai,bj) · log[p(ai) · p(bj) / p(ai/bj) · p(bj)]

=-

 

p(ai,bj) · log[p(ai) · p(bj) / p(ai,bj)]

i 1 r

j1 s

i 1 r

j1 s

i 1 r

j1 s

i 1

j1

obvio pues p(ai/bj) · p(bj) =

p(ai,bj) Resumiendo: I(A;B) = -

r

s

i 1

j1

 


Hemos subrayado la expresión que sigue al signo menos, pues continuaremos el razonamiento, sólo con ella: supondremos que r

s

i 1

j1

 

p(ai,bj) · log{p(ai) · p(bj) / p(ai,bj)} r

la base del logaritmo es V

s

= [1/ln(V)] · 



p(ai,bj) · ln{p(ai) · p(bj) / p(ai,bj)}

 [1/ln(V)] · 



p(ai,bj) · {[p(ai) · p(bj) / p(ai,bj)] - 1}

= [1/ln(V)] · 



{p(ai,bj) · [p(ai) · p(bj) / p(ai,bj)] - p(ai,bj)}

= [1/ln(V)] · 



{p(ai) · p(bj) - p(ai,bj)}

i 1 r

i 1 r i 1 r

i 1 r

= [1/ln(V)] ·{ 

j1 s

j1 s j1 s j1 s

pues ln(z)  z-1 distribuyendo p(ai,bj) obvio

s



p(ai,bj)}


= [1/ln(V)] ·{  p(ai) ·  p(bj) - 



p(ai,bj)}

p(ai) no depende de j

= [1/ln(V)] ·{  p(ai) · 1



p(ai,bj)}

i 1 r i 1 r



r

p(ai) · p(bj) - 


j1

i 1 r

s

i 1 r

j1

i 1 r

r

i 1 r

i 1 r

i 1

i 1

-

i 1

j1 s

j1 s

j1

s

pues



j1

p(bj) = 1

s

= [1/ln(V)] ·{  p(ai) - 



p(ai,bj)}

= [1/ln(V)] ·{  p(ai) - 



p(bj/ai) · p(ai)}

j1 s j1

obvio

76

pues p(ai,bj) = p(bj/ai) · p(ai)

r

r

s

i 1 r

i 1 r

j1

= [1/ln(V)] ·{  p(ai) -  p(ai) ·  p(bj/ai)}

p(ai) no depende de j s

= [1/ln(V)] ·{  p(ai) -  p(ai) · 1}

pues

= [1/ln(V)] ·{  p(ai) -  p(ai) }

obvio

= [1/ln(V)] ·{ 0 } =0

obvio obvio

i 1 r

i 1 r

i 1

i 1

Resumiendo: r

s

i 1

j1

 

p(ai,bj) · log{p(ai) · p(bj) / p(ai,bj)}  0

Luego, incluyendo al signo menos, resulta: -

r

s

i 1

j1

 

p(ai,bj) · log{p(ai) · p(bj) / p(ai,bj)}  0

Es decir: I(A;B)  0 Dado que en la propiedad ln(z)  z-1 la igualdad se da en z=1, I(A;B) = 0 cuando [p(ai) · p(bj) / p(ai,bj)] = 1, es decir cuando p(ai) · p(bj) = p(ai,bj) Esto es, cuando los sucesos ai,bj son independientes.

77



j1

p(bj/ai) = 1

RECIPROCIDAD DE LA INFORMACIÓN MUTUA I(A;B) = I(B;A) Demostración: r

1)

r

p(ai/bj) =  p(bj/ai) · p(ai) / p(bj)



i 1

por Bayes

i 1

r

= [1/p(bj)] ·



i 1

p(bj/ai) · p(ai)

= [1/p(bj)] · p(bj) =1

pues p(bj) es independiente de i cálculo de p(bj)

Este resultado puede interpretarse así: recibido un símbolo de salida bj, se ha enviado -necesariamente- algún símbolo de entrada ai. Por definición I(B;A) = H(B) - H(B/A) 2) s

H(B) =  p(bj) · log[1/p(bj)] · 1 j1 s

r

=  p(bj) · log[1/p(bj)] · [  p(ai/bj)] j1 s

r

=



p(bj) · log[1/p(bj)] · p(ai/bj)

=



p(ai/bj) · p(bj) · log[1/p(bj)]

=



p(ai,bj) · log[1/p(bj)]

j1 s j1 s j1

por 1)

i 1

i 1 r

i 1 r i 1

propiedades de sumatoria conmutatividad pues p(ai/bj) · p(bj) =

p(ai,bj) r

=

i 1

s



j1

p(ai,bj) · log[1/p(bj)]


3) Ya vimos que: r

H(B/A) = 

i 1

s



j1


De 2 y 3 resulta que: I(B;A) = H(B) - H(B/A) r

s

r

s

=



p(ai,bj) · log[1/p(bj)] - 

=



{ p(ai,bj) · log[1/p(bj)] - p(ai,bj) · log[1/p(bj/ai)] }

i 1 r i 1

j1 s j1

i 1



j1


78


r

s

=



p(ai,bj) · { log[1/p(bj)] - log[1/p(bj/ai)] }

=



p(ai,bj) · log[1/p(bj)

=



p(ai,bj) · log[p(bj/ai)/p(bj)]

medios con medios,

obvio

i 1 r

i 1 r

i 1

j1 s j1 s j1

/

1/p(bj/ai)]

factorizando p(ai,bj) log a - log b = log a/b

etc. r

s

=



p(ai,bj) · log[p(bj/ai) · p(ai) / p(bj) · p(ai)]

=



p(ai,bj) · log[p(ai,bj) / p(bj) · p(ai)]

=



p(ai,bj) · log[p(ai,bj) / p(ai) · p(bj)]

=



p(ai,bj) · log[p(ai) · p(bj) / p(ai,bj)]-1

propiedades de exponente



i 1 r

i 1 r i 1 r

j1 s j1 s j1 s

i 1 j1 r s

= -

i 1



j1

pues p(bj/ai) · p(ai) = p(ai,bj) obvio

Que es exactamente la misma expresión que hallamos antes para I(A;B). Luego: I(B;A) = I(A;B)

79

OTROS RESULTADOS 1) Dado que I(A;B) = I(B;A) y I(A;B)  0, es obvio que I(B;A)  0 2) También, dado que I(A;B) = H(A) - H(A/B) y I(B;A) = H(B) - H(B/A), por 1 H(A)  H(A/B) y H(B)  H(B/A) 3) H(A,B) r

s

=



p(ai,bj) · log[1/p(ai,bj)]

=



p(bj/ai) · p(ai) · log[1 / p(bj/ai)·p(ai)]

=



p(bj/ai) · p(ai) · {log[1/p(bj/ai)] + log[1/p(ai)]}

=



{ p(bj/ai) · p(ai) · log[1/p(bj/ai)] + p(bj/ai) · p(ai) · log[1/p(ai)] }

=



p(bj/ai) · p(ai) · log[1/p(bj/ai)]

+




i 1 r

i 1 r i 1 r i 1 r

i 1 r i 1 r

j1 s j1 s j1 s j1 s j1 s j1

pues p(ai,bj) = p(bj/ai)·p(ai) log ab=log a+log b


s

=  p(ai) ·  p(bj/ai) · log[1/p(bj/ai)] i 1 r

+

i 1 r

p(ai) es independiente de j

j1

s



j1


=  p(ai) · H(B/ai) i 1 r

+

i 1

obvio

definición de H(B/ai)

s



j1

p(bj/ai) · p(ai) · log[1/p(ai)] r

= H(B/A) + 

i 1 r

s



j1


= H(B/A) +  p(ai) · log[1/p(ai)] · i 1

definición de H(B/A)

s



j1

p(bj/ai)

; p(ai)·log[1/p(ai)] es independiente de

j r

s

= H(B/A) +  p(ai) · log[1/p(ai)] · 1

pues

i 1

= H(B/A) + H(A) = H(A) + H(B/A)



j1

p(bj/ai) = 1

obvio

Resumiendo: H(A,B) = H(A) + H(B/A) 4) Análogamente, utilizando p(ai,bj) = p(ai/bj)·p(bj), H(A,B) = H(B) + H(A/B)

80

5) Nótese que cuando p(ai) · p(bj) = p(ai,bj), resulta que: H(B/A) = H(B) En efecto, r

s

H(B/A) = 




=



p(ai,bj) · log[1·p(ai) / p(bj/ai)·p(ai)]

obvio

=



p(ai,bj) · log[1·p(ai) / p(ai,bj)]

pues p(bj/ai)·p(ai) = p(ai,bj)

=



p(ai) · p(bj) · log[1·p(ai) / p(ai)·p(bj)]

pues p(ai,bj) = p(ai) · p(bj)

=



p(ai) · p(bj) · log[1/p(bj)]

obvio

i 1 r

i 1 r i 1 r i 1 r

i 1 r

j1 s

j1 s j1 s j1 s j1

s

=  p(ai) ·  p(bj) · log[1/p(bj)]

p(ai) es independiente de j

=  p(ai) · H(B)

definición de H(B)

= H(B)

obvio

i 1 r

j1

i 1

Análogamente H(A/B) = H(A). De donde, cuando hay independencia: H(A,B) = H(A) + H(B) = H(B) + H(A) 6) I(A;B) = H(A) - H(A/B) = H(A) + H(B) - [H(B) + H(A/B)] = H(A) + H(B) - H(A,B)

obvio por 4

Resumiendo: I(A;B) = H(A) + H(B) - H(A,B) O también: H(A,B) = H(A) + H(B) - I(A;B) Como I(A;B)  0, resulta que: H(A) + H(B)  H(A,B) 7) Como I(A;B) = H(B) - H(B/A) = H(A) - H(A/B) r

=

i 1

s



j1

p(ai,bj) · log[p(ai,bj) / p(ai) · p(bj)]

Como p(ai) y p(bj/ai) están definidas: Para calcular I(A;B) podemos hallar H(B) y H(B/A) por separado, aquí requerimos deducir p(bj). O bien, podemos hallar H(A) y H(A/B) por separado, aquí requerimos deducir p(ai/bj) y p(bj). O bien , requerimos hallar p(bj) junto a las probabilidades conjuntas p(ai,bj). [Esto último es lo que suele hallarse en alguna literatura]. 81

I(A;B)  min{ log|A| , log|B| } Ya vimos que: I(A;B) = I(B;A) I(A;B) = H(A) - H(A/B)

I(B;A) = H(B) - H(B/A)

Como I(A;B)  0 : H(A)  H(A/B)

Como I(A;B)  0 : H(B)  H(B/A)

Luego, cuando H(A/B) = H(A) entonces I(A;B) = 0

Luego, cuando H(B/A) = H(B) entonces I(B;A) = 0

Pero, cuando H(A/B) = 0 entonces I(A;B) = H(A)

Pero, cuando H(B/A) = 0 entonces I(B;A) = H(B)

Luego, el valor máximo para la información mutua entre A y B es H(A) o bien H(B). Por propiedades de la entropía sabemos que H(S)  log(q) -donde q es el número de símbolos-. Podemos aplicar este resultado y por lo tanto: H(A)  log(|A|) y H(B)  log(|B|) Es decir, I(A;B)  min{ log(|A|) , log(|B|) }

Si reunimos el hecho de que la información mutua es no negativa resulta que: 0  I(A;B)  min{log|A| , log|B|}

82

CANALES ESPECIALES Asumiremos que en la matriz del canal P, no hay filas de ceros (prohibido por definición -cada fila debe sumar uno-) o columnas de ceros (lo que significaría que el símbolo de salida correspondiente nunca se recibe y por lo tanto podemos prescindir de él). Canales sin ruido (o sin pérdida).- La matriz P tiene la propiedad de tener un y sólo un elemento distinto de cero en cada columna. Esta condición obliga a tener tantos o más símbolos de salida como de entrada (r  s). s

r

j1

i 1

Como H(A/B) =  p(bj) ·  p(ai/bj) · log[1/p(ai/bj)] Mostraremos que la segunda sumatoria es una suma de ceros. Luego, s

r

j1

i 1

H(A/B) =  p(bj) ·  p(ai/bj) · log[1/p(ai/bj)] = En efecto, como p(ai/bj) = p(bj/ai)·p(ai) / p(bj)

s



j1

p(bj) · 0 = 0

por Bayes

r

= p(bj/ai)·p(ai) /



i'1

p(bj/ai') · p(ai')

cálculo de p(bj), usar i' no afecta

Para los sumandos tales que p(bj/ai) = 0, es claro que p(ai/bj) = 0 y por tanto p(ai/bj) · log[1/p(ai/bj)] = 0. Para los sumandos tales que p(bj/ai)  0, es claro que

r



i'1

p(bj/ai') · p(ai') recorre la

columna j-ésima, que tiene todos sus elementos ceros -excepto uno- precisamente p(bj/ai). Luego, p(ai/bj) = p(bj/ai)·p(ai) / p(bj/ai)·p(ai) = 1, y por tanto p(ai/bj) · log[1/p(ai/bj)] = 0. Luego, I(A;B) = H(A) - H(A/B) = H(A) - 0 = H(A) Ejemplo de canal sin ruido: Sea el canal cr=(A,P,B) A = {a1,a2} B = {b1,b2,b3} p(a1) = 2/3 P=

a1 a2

b1 1/2 0

p(b1) = 1/3 p(b2) = 1/3 H(A) = 0.9183 bits H(B) = 1.585 bits H(A/B) = 0 bits H(B/A) = 0.6667 bits H(A,B) = 1.5850 bits I(A;B) = 0.9183 bits

b2 1/2 0

p(a2) = 1/3

b3 0 1

p(b3) = 1/3

El canal sin ruido clásico, típico o ideal tiene r = s, ai = bi y P es la matriz identidad.

83

Canales determinantes o determinísticos.- La matriz P tiene la propiedad de tener un y sólo un elemento distinto de cero en cada fila. Es decir, P tiene un y sólo un 1 en cada fila. Esta condición obliga a tener tantos o más símbolos de entrada como de salida (r  s). r

s

i 1

j1

Como H(B/A) =  p(ai) ·  p(bj/ai) · log[1/p(bj/ai)] La segunda sumatoria (que recorre la fila ai) se comporta así: s



j1

p(bj/ai) · log[1/p(bj/ai)] = p(b1/ai) · log[1/p(b1/ai)] + ... + p(bs/ai) · log[1/p(bs/ai)]

Para los elementos tales que p(bj/ai) = 0, es claro que p(bj/ai) · log[1/p(bj/ai)] = 0 Para los elementos tales que p(bj/ai) = 1, es claro que p(bj/ai) · log[1/p(bj/ai)] = 0 s

Así pues, es una suma de ceros, es decir,



j1

p(bj/ai) · log[1/p(bj/ai)] = 0. Luego,

r

H(B/A) =



i 1

p(ai) · 0 = 0

Luego, I(A;B) = H(B) - H(B/A) = H(B) - 0 = H(B) Ejemplo de canal determinístico: Sea el canal cr=(A,P,B) A = {a1,a2,a3} B = {b1,b2} p(a1) = 1/3 p(a2) = 1/3 P=

a1 a2 a3

b1 1 1 0

b2 0 0 1

p(b1) = 2/3 p(b2) = 1/3 H(A) = 1.585 bits H(B) = 0.9183 bits H(A/B) = 2/3 bits H(B/A) = 0 bits H(A,B) = 1.5850 bits I(A;B) = 0.9183 bits

84

p(a3) = 1/3

Canales ambiguos.- Son tales que H(A) = H(A/B), es decir I(A;B) = 0. Son tan ruidosos que no dejan pasar información. Ejemplo de canal ambiguo: Sea el canal cr=(A,P,B) A = {a1,a2} B = {b1,b2} p(a1) = 1/3 P=

B1 1/2 1/2

a1 a2

p(a2) = 2/3

b2 1/2 1/2

p(b1) = 1/2 p(b2) = 1/2 H(A) = 0.9183 bits H(B) = 1 bits H(A/B) = 0.9183 bits H(B/A) = 1 bits H(A,B) = 1.9183 bits I(A;B) = 0 bits

Note que si las filas de P son iguales : r

s

i 1

j1

En la definición de H(B/A) =  p(ai) ·  p(bj/ai) · log[1/p(bj/ai)] Al ser las filas iguales, la segunda sumatoria da el mismo resultado para cada ai. s

Sea c tal constante, es decir,



j1

p(bj/ai) · log[1/p(bj/ai)] = c

(1)

Luego: r

H(B/A) =



i 1

r

p(ai) · c = c ·  p(ai) = c · 1 = c i 1

r

Por otro lado, en el cálculo de p(bj) =  p(bj/ai) · p(ai) i 1

Al ser las filas iguales, el valor de p(bj/ai) es el mismo para cada ai. Digamos p(bj/ai) = k r

r

r

i 1

i 1

Luego, p(bj) =  p(bj/ai) · p(ai) =  k · p(ai) = k ·  p(ai) = k · 1 = k i 1

Es decir, p(bj) = k = p(bj/ai)

(para algún i, el que sea pues las filas son iguales)

s

Por tanto, H(B) =  p(bj) · log[1/p(bj)] j1 s

=



j1

p(bj/ai) · log[1/p(bj/ai)]

=c

por (2) por (1)

Luego, I(A;B) = H(B) - H(B/A) = c - c = 0 Si un canal tiene su matriz P con las filas iguales entonces es ambiguo.

85

(2)

Canal simétrico o uniforme.- Sea NUM la secuencia: num1, ... ,nums Su matriz P es tal que: Cada fila es una permutación de NUM. Cada columna es una permutación de NUM. Ejemplo de canal uniforme o simétrico: Sea el canal cr=(A,P,B) A = {a1,a2,a3,a4} B = {b1,b2,b3,b4} p(ai) = 1/4 NUM: 0, 1/4, 1/4, 1/2

P=

a1 a2 a3 a4

b1 1/2 1/4 0 1/4

b2 1/4 1/2 1/4 0

b3 1/4 0 1/4 1/2

b4 0 1/4 1/2 1/4

Canal débilmente simétrico.- Sea NUM la secuencia: num1, ... ,nums Su matriz P es tal que: Cada fila es una permutación de NUM. Las columnas suman lo mismo. Es obvio que un canal simétrico es débilmente simétrico también. Ejemplo de canal débilmente simétrico: Sea el canal cr=(A,P,B) A = {a1,a2} B = {b1,b2,b3,b4} p(ai) = 1/2 NUM: 0, 1/4, 1/4, 1/2

P=

a1 a2

b1 1/2 0

b2 1/4 1/4

b3 1/4 1/4

b4 0 1/2

Canal binario simétrico CBS (BSC por las siglas del nombre en inglés, Binary Symmetric Channel).- Su matriz es así:

P=

a1 a2

b1 p q

b2 q p

donde q = 1-p

Generalmente se utiliza A = {a1,a2} = {0,1} = {b1,b2} = B p(b1/a1) = p(0/0) = p(b2/a2) = p(1/1) = p p(b1/a2) = p(0/1) = p(b2/a1) = p(1/0) = q p es la probabilidad de acierto q es la probabilidad de error

86

Canal binario borrador CBB (BEC por las siglas del nombre en inglés, Binary Erasure Channel).- Su matriz es así:

P=

a1 a2

b1 p 0

b2 q q

b3 0 p

donde q = 1-p

Generalmente se utiliza A = {a1,a2} = {0,1} y B = {b1,b2,b3} = {0,?,1} "?" representa un símbolo de salida 'borroneado' p(b1/a1) = p(0/0) = p(b3/a2) = p(1/1) = p p(b2/a1) = p(?/0) = p(b2/a2) = p(?/0) = q p es la probabilidad de acierto q es la probabilidad de 'borroneo'

87

CANALES EN SERIE Consideremos un par de canales conectados en serie (o en cascada) así:

A --> canaldeAaB --> B --> canaldeBaC --> C

A={ a1, ... ,ar } es el alfabeto de entrada (al primer canal) B={ b1, ... ,bs } es el alfabeto de salida (del primer canal) y de entrada (al segundo canal) C={ c1, ... ,ct } es el alfabeto de salida (del segundo canal) Cada canal tiene su propia matriz con probabilidades p(bj/ai) para el primer canal p(ck/bj) para el segundo canal Al enviar ai, este símbolo atraviesa el primer canal, que tiene como salida bj; dicho bj ingresa al segundo canal que tiene como salida ck. Se asume la siguiente condición: la salida ck depende solamente de bj y no de ai Es decir, se asume en esta definición de canales en serie que: i) p(ck/ai,bj) = p(ck/bj) También podemos asumir que: ii) p(ai/bj,ck) = p(ai/bj) En efecto, se sabe que: 1) p(ai,bj,ck) = p(ck/ai,bj) · p(ai,bj) = p(ai/bj,ck) · p(bj,ck) = p(ai/bj,ck) · p(ck/bj) · p(bj) p(ai,bj,ck) / p(ai,bj) = p(ai/bj,ck)·p(ck/bj)·p(bj) / p(ai,bj) = p(ai/bj,ck)·p(ck/bj)·p(bj) / p(ai/bj)·p(bj) p(ai,bj)=p(ai/bj)·p(bj) = p(ai/bj,ck)·p(ck/bj) / p(ai/bj) 'Despejando' p(ai/bj,ck) tenemos: p(ai/bj,ck) = p(ai,bj,ck)·p(ai/bj) / p(ai,bj)·p(ck/bj) = p(ck/ai,bj)·p(ai,bj)·p(ai/bj) / p(ai,bj)·p(ck/bj) = p(ck/ai,bj)·p(ai/bj) / p(ck/bj) = p(ck/bj)·p(ai/bj) / p(ck/bj) = p(ai/bj)

luego: Por 1) pues obvio

por 1) obvio por i) obvio

Es interesante mostrar que los canales en serie tienden a perder información. Ello se logra comparando I(A;B) con I(A;C). Es lo que haremos a continuación. Previamente definiremos: t

t

r

k 1

k 1

i 1

H(A/C) =  p(ck) · H(A/ck) =  p(ck) ·  p(ai/ck) · log[1/p(ai/ck)]

I(A;C) = H(A) - H(A/C) 88

I(A;C)  I(A;B) Demostración: Probaremos que I(A;C) - I(A;B)  0 Como I(A;C) = H(A) - H(A/C) y I(A;B) = H(A) - H(A/B) entonces I(A;C) - I(A;B) = H(A) - H(A/C) - [H(A) - H(A/B)] = H(A/B) - H(A/C) Es decir, probaremos que H(A/B) - H(A/C)  0 Utilizaremos los siguientes resultados: r

r

i 1

i 1

iii) p(bj) =  p(bj/ai) · p(ai) =  p(ai,bj)

[cálculo de p(bj)]

iv) En el segundo canal -por definición- sus filas deben sumar 1, es decir t



k 1

p(ck/bj) = 1

v) Análogamente a como se calcula p(bj) en el primer canal, podemos calcular p(ck) en el segundo así: s

s

j1

j1

p(ck) =  p(ck/bj) · p(bj) =  p(bj,ck) s

vi) p(ai/ck) =  p(ai/bj) · p(bj/ck)

[conocido resultado estadístico]

j1

Empecemos: s

r

H(A/B) = 




=



p(ai,bj) · log[1/p(ai/bj)] ·

j1 s

j1 s

i 1 r

i 1 r

por definición t



k 1

p(ck/bj)

por iv)

t

=

 

p(ai,bj) · log[1/p(ai/bj)] · p(ck/bj)

=

 

p(ck/bj) · p(ai,bj) · log[1/p(ai/bj)]

conmutatividad

=

 

p(ck/ai,bj) · p(ai,bj) · log[1/p(ai/bj)]

por i)

=

 

p(ai,bj,ck) · log[1/p(ai/bj)]

evidente

=

 

p(ai,bj,ck) · log[1/p(ai/bj)]

j1 s

j1 s j1 s

j1 s

i 1 r

k 1 t

i 1 r

k 1 t

i 1 r

k 1 t

i 1 t

k 1 r

j1 k 1 i 1

89



t

r

k 1 t

i 1 r

k 1 t

i 1 r

H(A/C) =  p(ck) ·  p(ai/ck) · log[1/p(ai/ck)] =  p(ck) ·  s

por definición

s



j1

p(ai/bj) · p(bj/ck) · log[1/p(ai/ck)]

por vi)

=

 

p(ck) · p(ai/bj) · p(bj/ck) · log[1/p(ai/ck)]

prop. de sumatoria

=

 

p(ai/bj) · p(bj/ck) · p(ck) · log[1/p(ai/ck)]

conmutatividad

=

 

p(ai/bj,ck) · p(bj/ck) · p(ck) · log[1/p(ai/ck)]

por ii)

=

 

p(ai/bj,ck) · p(bj,ck) · log[1/p(ai/ck)]

evidente

=

 

p(ai,bj,ck) · log[1/p(ai/ck)]

evidente

=

 



k 1 j1 t s

i 1 r

k 1 j1 t s

i 1 r

k 1 j1 t s

i 1 r

k 1 j1 t s

i 1 r

k 1 j1 t s

i 1 r

j1 k 1 i 1

Luego, H(A/B) - H(A/C) s

t

r

s

t

r

=

 

p(ai,bj,ck) · log[1/p(ai/bj)] -

=

 

p(ai,bj,ck) · log[1/p(ai/bj)] - p(ai,bj,ck) · log[1/p(ai/ck)]

=

 

p(ai,bj,ck) · {log[1/p(ai/bj)] - log[1/p(ai/ck)]}

=

 

p(ai,bj,ck) · {log[1/p(ai/bj) / 1/p(ai/ck)]}

=

 

p(ai,bj,ck) · log[p(ai/ck) / p(ai/bj)]

=

 

p(ai/bj,ck) · p(bj,ck) · log[p(ai/ck) / p(ai/bj)]

=



p(bj,ck) ·  p(ai/bj,ck) · log[p(ai/ck) / p(ai/bj)]

obvio

=



p(bj,ck) ·  p(ai/bj) · log[p(ai/ck) / p(ai/bj)]

por ii)

j1 k 1 i 1 r t s j1 k 1 i 1 r t s j1 k 1 i 1 r t s j1 k 1 i 1 r t s j1 k 1 i 1 r t s j1 k 1 i 1 t s j1 k 1 t s j1 k 1

  

j1 k 1 i 1


i 1

s

sale p(ai,bj,ck) log a - log b = log a/b medios con medios, etc. evidente

r

i 1 r

= 1/ln(V) · 

prop. sumatoria

t



j1 k 1

r

p(bj,ck) ·  p(ai/bj) · ln[p(ai/ck) / p(ai/bj)] i 1

90

evidente

r

t

s



p(bj,ck) ·  p(ai/bj) · [p(ai/ck) / p(ai/bj) - 1]

pues ln(z)  z -1



p(bj,ck) ·  [p(ai/ck) - p(ai/bj)]

obvio

= 1/ln(V) · 



p(bj,ck) · [  p(ai/ck) -

= 1/ln(V) · 



p(bj,ck) · [1 -1] = 1/ln(V) · 

 1/ln(V) · 

= 1/ln(V) · 

j1 k 1 t s j1 k 1 t s j1 k 1 t s j1 k 1

i 1 r

i 1 r

i 1

r



i 1 s

p(ai/bj)] t



j1 k 1

r

El último paso es lícito si mostramos que



i 1

evidente

p(bj,ck) · 0 = 0 r

p(ai/ck) =  p(ai/bj) = 1 i 1

Lo que hacemos a continuación: r



i 1 r



i 1

p(ai/bj) = 1 r

se ha demostrado en la página 78 s

p(ai/ck) = 



p(ai/bj) · p(bj/ck)

por vi)

=



p(ai/bj) · p(bj/ck)

evidente

i 1 s

j1 s

j1 r

i 1

r

=  p(bj/ck) ·  p(ai/bj)

p(bj/ck) es independiente de i

=  p(bj/ck) · 1

demostrado en la página 78

=  p(ck/bj)·p(bj) / p(ck)

Bayes

i 1

j1 s

j1 s j1

s

= [1/p(ck)] ·  p(ck/bj)·p(bj)

obvio

j1

= [1/p(ck)] · p(ck) =1

por v)

Resumiendo: H(A/B) - H(A/C)  0, es decir I(A;C) - I(A;B)  0, es decir, I(A;C)  I(A;B) A partir de la línea en que se utiliza la propiedad ln(z)  z -1, sería innecesario lo que sigue del razonamiento si p(bj,ck)=0. Así pues cuando p(bj,ck)0, la condición para la igualdad es que p(ai/ck) = p(ai/bj). También se conoce esto como el Teorema del Procesamiento de Datos (o de Información).

91

Ejemplo: p(a1) = 1/2

A

p(a2) = 1/2

canal 1 0.9 0.1  0.1 0.9  

canal 2 0.8 0.2 B   C 0.2 0.8

I(A;C) = 0.173253627507381  0.531004406410718 = I(A;B)

Ejemplo (del libro de Togneri): p(a1) = 1/2

p(a2) = 1/2

canal 1 A

1 / 2 0 1 / 2 1 / 3 1 / 3 1 / 3  

B

canal 2 3 / 4 0 1 / 4   0 1 0  C   1 / 4 0 3 / 4

I(A;C) = 0.190874504621109 = I(A;B) Nótese que cuando p(bj,ck)=0 no es necesario que p(ai/ck) = p(ai/bj). Por ejemplo: p(b1,c2)=0 pero p(a1/c2)=0  3/5=p(a1/b1) En cambio. cuando p(bj,ck)0, la condición para la igualdad es que p(ai/ck) = p(ai/bj). Por ejemplo: p(b1,c1)=5/160 y p(a1/c1)=3/5=p(a1/b1)

92

ADITIVIDAD DE LA INFORMACIÓN MUTUA ¿ Qué pasa si a cada símbolo enviado ai le corresponde más de un símbolo de salida ? Ello puede darse cuando enviamos símbolos no a través de un canal sino de dos (o más) canales. Por ejemplo: primer canal

--> B

segundo canal

---> C

A -->

Por generalidad, llamaremos C al segundo alfabeto de salida, donde C={ c1, ... ,ct }. Es claro que los dos (o más) canales pueden ser idénticos (es decir, tienen la misma matriz P). Esta situación es análoga a aquella cuando repetimos el envío de los símbolos de entrada dos (o más) veces, por el mismo canal.

Mostraremos -para el caso de dos canales o la repetición un par de veces del envío de cada símbolo- que esta redundancia reduce la pérdida de información [o, dicho de otro modo, adiciona información a I(A;B)]. Sean: p(ai/bj,ck) : la probabilidad de enviar ai dado que se reciben bj y ck p(ck/ai,bj) : la probabilidad de recibir ck dado que se envía ai y se recibe bj p(ck/ai) : la probabilidad de recibir ck dado que se envía ai Asumiremos que la (segunda) salida ck no depende de la (primera) salida bj, es decir: 1) p(ck/ai,bj) = p(ck/ai) 2) Definiremos

I(A; B,C) = H(A) - H(A/ B,C)

donde

r

3) H(A/ bj,ck) =  p(ai/bj,ck) · log[1/p(ai/bj,ck)] i 1 s

4) H(A/ B,C) = 

t



j1 k 1 t s

=



j1 k 1 t s

p(bj,ck) · H(A/bj,ck) r

p(bj,ck) ·  p(ai/bj,ck) · log[1/p(ai/bj,ck)] i 1

por definición

r

=

 

p(bj,ck) · p(ai/bj,ck) · log[1/p(ai/bj,ck)]

obvio

=

 

p(ai/bj,ck) · p(bj,ck) · log[1/p(ai/bj,ck)]

obvio

=

 

p(ai,bj,ck) · log[1/p(ai/bj,ck)]

evidente

j1 k 1 i 1 r t s

i 1 r

i 1

j1 k 1 t s

j1 k 1

93

5) Es claro que: r

H(A) =  p(ai) · log[1/p(ai)] i 1 r

s

=  p(ai) · log[1/p(ai)] ·  p(bj/ai) i 1 r

la suma de una fila es 1

j1

s

=




evidente

=




evidente



p(ai,bj) · log[1/p(ai)] ·  p(ck/ai)

i 1 r

j1 s

i 1 r

j1 s

=

i 1 r

t

k 1

j1 s

la suma de una fila es 1

t

=

 

p(ck/ai) · p(ai,bj) · log[1/p(ai)]

evidente

=

 

p(ck/ai,bj) · p(ai,bj) · log[1/p(ai)]

por 1)

=

 

p(ai,bj,ck) · log[1/p(ai)]

evidente

i 1 r

j1 k 1 t s

i 1 r

j1 k 1 t s

i 1

j1 k 1

Como por definición: I(A; B,C) = H(A) - H(A/ B,C) 6) Resulta que, por 5 y 4: r

I(A; B,C) = 

i 1 r

-

t

s

 

j1 k 1 t s

   i 1 r

j1 k 1 t s

p(ai,bj,ck) · log[1/p(ai)] p(ai,bj,ck) · log[1/p(ai/bj,ck)]

=

 

{ p(ai,bj,ck) · log[1/p(ai)] - p(ai,bj,ck) · log[1/p(ai/bj,ck)] }

obvio

=

 

p(ai,bj,ck) · {log[1/p(ai)] - log[1/p(ai/bj,ck)]}

obvio

=

 

p(ai,bj,ck) · log[ 1/p(ai)

=

 

p(ai,bj,ck) · log[p(ai/bj,ck) / p(ai)]

=

 

p(ai,bj,ck) · log[p(ai/bj,ck)·p(bj,ck) / p(ai)·p(bj,ck)]

i 1 r

i 1 r i 1 r i 1 r

i 1

j1 k 1 t s j1 k 1 t s j1 k 1 t s j1 k 1 t s j1 k 1

/

1/p(ai/bj,ck) ]

logaritmos medios, etc.

obvio r

=

i 1

s

t

 

j1 k 1

p(ai,bj,ck) · log[p(ai,bj,ck) / p(ai)·p(bj,ck)]

94

evidente

Resumiendo: r

I(A; B,C) = 

i 1

s

t

 

j1 k 1

p(ai,bj,ck) · log[p(ai,bj,ck) / p(ai)·p(bj,ck)]

Consideremos la información mutua entre A y C -dado que se conoce B-, es decir, la cantidad de información que proporciona el segundo canal, de manera adicional luego de utilizar el primer canal. Definámosla así: I(A;C / B) = H(A/B) - H(A/ B,C) Y si adicionamos (sumamos) I(A;B) a esta expresión resulta que: I(A;B) + I(A;C / B) = H(A) - H(A/B) + H(A/B) - H(A/ B,C) = H(A) - H(A/ B,C) = I(A; B,C) Es decir, I(A; B,C) = I(A;B) + I(A;C / B) Que se puede interpretar así: la información mutua entre A y (B,C) es la información mutua entre A y B, más la información mutua entre A y C -dado que se conoce B-.

Lo que muestra que la redundancia reduce la pérdida de información; o de un modo más optimista obtiene ganancia de información; o aumento de confiabilidad.

Por otro lado, también podemos definir I(A; B,C) de este otro modo: I(A; B,C) = H(B,C) - H(B,C / A) Donde H(B,C) y H(B,C / A) se definen de manera análoga a las entropías que hemos estado utilizando.

95

Ejemplo: Es un ejemplo clásico trabajar con dos canales idénticos binarios simétricos. Es decir, hallar I(A; B,C) considerando el siguiente CBS. A = { a1 , a2 } = { 0 , 1 } B = { b1 , b2 } = { 0 , 1 } C = { c1 , c2 } = { 0 , 1 } p(a1) = p(0) = 1/2

P=

p(a2) = p(1) = 1/2 b1 p q

a1 a2

b2 q p donde q = 1-p

=

c1 p q

a1 a2

c2 q p

Como se observa, la matriz vale tanto para el primer canal como para el segundo. Es decir, P representa p(bj/ai) y también P representa p(cj/ai) Es obvio que p(ai) es un dato dado. Si utilizamos la expresión hallada en 6) es posible hacer el cálculo de I(A; B,C) sabiendo que: i) p(ai,bj,ck) = p(ck/ai,bj) · p(ai,bj) = p(ck/ai) · p(ai,bj) p(ck/ai) se obtiene de la matriz P [es equivalente a p(bk/ai)] ii) p(ai,bj) = p(bj/ai) · p(ai) p(bj/ai) se obtiene de la matriz P iii) p(bj,ck) = p(ck/bj) · p(bj) r

p(ck/bj) =  p(ck/ai) · p(ai/bj) i 1

Ya vimos cómo calcular p(ai/bj) y p(bj) El cálculo da: ai 0 0 0 0 1 1 1 1

bj 0 0 1 1 0 0 1 1

ck 0 1 0 1 0 1 0 1

p(ai) 1/2 1/2 1/2 1/2 1/2 1/2 1/2 1/2

I(A; B,C) = p2 · log (2·p2 / p2+q2)

p(bj,ck) (p2+q2) / 2 p·q p·q 2 (p +q2) / 2 (p2+q2) / 2 p·q p·q (p2+q2) / 2 + q2 · log (2·q2 / p2+q2)

96

p(ai,bj,ck) p2/2 (p·q) / 2 (p·q) / 2 q2/2 q2/2 (p·q) / 2 (p·q) / 2 p2/2

REDUCCIÓN DE CANALES Sea un canal ruidoso con matriz P de r entradas y s salidas. Sea una nueva matriz P' construida a partir de P así: conserva las r entradas pero tiene (s-1) salidas, fruto de agrupar y sumar dos columnas en una sola (de ahí que se reduce una columna). Diremos que P' es una reducción elemental de P Obviamente esto puede hacerse una y otra vez obteniendo sucesivas reducciones: el canal resultante es una reducción de P. Si bien se agrupan y suman dos columnas arbitrarias, podemos suponer -para algunos resultados teóricos- sin pérdida de generalidad que las columnas que se asocian son las dos primeras. Una forma ingeniosa de ver la reducción de un canal es considerar tal reducción como si se tratara de un tratamiento en un "segundo" canal (en serie), así: a1 a2 a3 ... ar

b1 b2 --> ingresa al canal P --> b3 ... bs

c2 c2 --> "segundo canal" --> c3= b3 ... cs=bs

Dicho segundo canal obtiene -con probabilidad 1- las mismas salidas que las entradas para los símbolos b3,...,bs. Pero, los símbolos b1 y b2 se asocian con c2 (nótese que finalmente hay s-1 salidas, pues el subíndice para las c's -en el gráfico- empieza en 2): En términos de matrices tendríamos: Matriz del canal original

b1 P=

a1 ... ar

Matriz del segundo canal

... p(bj/ai)

bs P2 =

b1 b2 b3 ... bs

c2 1 1

c3

...

cs

1 ... 1

Los espacios en blanco tienen ceros. Desde p(c3/b3) hasta p(cs/bs) tiene la apariencia de una matriz identidad Nótese que este es un canal determinante. Vista la reducción elemental como dos canales en serie -y por ello esta forma es muy ingeniosa- podemos aplicar la propiedad para tales canales: I(A;C)  I(A;B)

97

Es decir, la información mutua, a lo más se mantiene (si es que no disminuye) cuando aplicamos una reducción elemental. Cuando la igualdad se preserva, el canal resultante recibe otro nombre además de reducción elemental de P: reducción suficiente. Pero sabemos -por lo que se muestra en canales en serie- que la condición para la igualdad cuando p(bj,ck)0 es: p(ai/ck) = p(ai/bj). Así pues, podemos escudriñar esta condición para una reducción elemental según nuestra representación. En la segunda matriz: i) Casos para j=3,...,s y kj Es claro que p(ck/bj)=0, luego p(bj,ck) = p(ck/bj)·p(bj)=0 (no hay ninguna condición que cumplir) ii) Casos para j=k (j,k=3,...,s) Es claro que p(ck/bk)=1, luego p(bk,ck) = p(ck/bk)·p(bk) = 1·p(bk) = p(bk)  0 r

(pues para que p(bk) =  p(bk/ai) · p(ai) i 1

sea 0 es necesario que haya una columna de

ceros en P y/o algún p(ai) sea cero, lo que no consideraremos) En este caso, es claro que : s

p(ai/ck) =  p(ai/bj) · p(bj/ck)

página 89, vi)

j1 s

=  p(ai/bj) · p(ck/bj) · p(bj) / p(ck)

Bayes

j1

= =

p(ai/bk) · p(bk) / p(ck) p(ai/bk)

columna k de sólo ceros, salvo si (k=j): p(ck/bk)=1 p(ck)=p(bk)

El último paso utiliza el hecho de que -con la segunda matrizs

p(ck) =  p(ck/bj) · p(bj) j1

= p(ck/bk) · p(bk) = p(bk)

columna k de sólo ceros, salvo si (k=j): p(ck/bk)=1

Así pues, cuando p(bk,ck)  0 la condición p(ai/ck) = p(ai/bk) se cumple. iii) Casos para j=1 y j=2 (k=3,...,s) Es claro que p(ck/bj)=0, luego p(bj,ck) = p(ck/bj)·p(bj)=0 (no hay ninguna condición que cumplir) iv) Resta analizar los casos p(b1,c2) y p(b2,c2) Es claro que p(c2/b2)=1, luego p(b2,c2) = p(c2/b2)·p(b2) = 1·p(b2) = p(b2)  0 Entonces la condición que debe satisfacerse para la igualdad es: p(ai/c2) = p(ai/b2)

98

Es claro que p(c2/b1)=1, luego p(b1,c2) = p(c2/b1)·p(b1) = 1·p(b1) = p(b1)  0 Entonces la condición que debe satisfacerse para la igualdad es: p(ai/c2) = p(ai/b1) Resumiendo: para los casos p(b1,c2)0 y p(b2,c2)0 las condiciones que deben cumplirse para que I(A;C)=I(A;B), es decir, para que la reducción elemental sea una reducción suficiente (que no afecte) son: p(ai/c2) = p(ai/b2) y p(ai/c2) = p(ai/b1) , es decir, p(ai/b2) = p(ai/b1) En todos los demás casos, la igualdad se mantendrá. p(ai/b1) = p(ai/b2) se puede reescribir -por Bayes en cada lado de la igualdad- así: p(b1/ai)·p(ai) / p(b1) = p(b2/ai)·p(ai) / p(b2) luego, es obvio que la condición es p(b1/ai) = p(b1)·p(b2/ai) / p(b2) = [p(b1)/p(b2)]·p(b2/ai) Resumiendo, la condición es: p(b1/ai) = [p(b1)/p(b2)] · p(b2/ai)

(i=1,...,r)

Dada la matriz P del canal original y dadas las probabilidades p(ai), resulta que p(b1) es fijo, p(b2) es fijo y por lo tanto [p(b1)/p(b2)] también es constante, llamémosla c. Luego la condición para que la reducción elemental sea una reducción suficiente es: p(b1/ai) = c · p(b2/ai)

(i=1,...,r)

En términos de la matriz P, esta condición puede describirse así: Que la columna 1 sea (sub)múltiplo de la columna 2 (cada uno de sus elementos). Ejemplo: Sea el canal cr=(A,P,B) A = {a1,a2} B = {b1,b2,b3} P=

a1 a2

b1 1/8 1/4

b2 1/4 1/2

p(ai) = 1/2 b3 5/8 1/4

Sea P' una reducción elemental de P

P' =

a1 a2

c2 3/8 3/4

c3=b3 5/8 1/4

Como -en P- la columna 1 es (sub)múltiplo de la columna 2, la reducción es suficiente.

99

CAPACIDAD DE UN CANAL Se define así:

C = max{ I(A;B) } p(ai)

La máxima información mutua, variando las probabilidades de entrada p(ai). Para P fijo, representa la máxima cantidad de información que el canal puede transmitir. Hay un algoritmo -el de Blahut/Arimoto- que estima con una aproximación aceptable dicha capacidad. Sin embargo, en ocasiones puede obtenerse tal capacidad directamente, como en el caso de los canales débilmente simétricos. Capacidad de un canal débilmente simétrico.- Sea NUM la secuencia: num1, ... ,nums Sea un canal débilmente simétrico con matriz P, tal que: A={ a1, ... ,ar } B={ b1, ... ,bs } Cada fila es una permutación de NUM. Las columnas suman lo mismo: digamos c. Se sabe que I(A;B) = H(B) - H(B/A). Mostraremos que H(B/A) es una cantidad constante. r

s

i 1

j1

En efecto, por definición H(B/A) =  p(ai) ·  p(bj/ai) · log[1/p(bj/ai)] Como la matriz P es fija y cada fila es una permutación de NUM, la segunda sumatoria siempre devuelve lo mismo, digamos k. Es decir, r

r

i 1

i 1

H(B/A) =  p(ai) · k = k ·  p(ai) = k · 1 = k

es decir,

s

H(B/A) = k =  p(bj/ai) · log[1/p(bj/ai)]

(para algún/cualquier i)

j1

Luego, I(A;B) = H(B) - k k=H(B/A) no depende de p(ai). Por lo tanto, maximizar el valor de I(A;B) para este canal -variando las probabilidades de entrada p(ai)- es equivalente a maximizar H(B). Se sabe que H(B)  log(s), pues |B|=s La igualdad se alcanza cuando p(bj)=1/s (para j=1,...,s) (es decir, cuando las probabilidades p(bj) son iguales -a un valor constante-) Sea p(ai)=1/r, entonces: r

p(bj) =  p(bj/ai) · p(ai) i 1 r

=  p(bj/ai) · 1/r i 1

cálculo de p(bj) tomando p(ai)=1/r

r

= 1/r ·  p(bj/ai) i 1

= 1/r · c = c/r

obvio canal débilmente simétrico, columnas suman c

100

Resumiendo: tomando p(ai)=1/r p(bj) = c/r

un valor constante

Más precisamente p(bj) = c/r = 1/s (nótese que c = r/s) Luego, H(B) alcanza su máximo valor cuando p(ai)=1/r Así pues, en un canal débilmente simétrico: C = max{ I(A;B) } = log(s) - k p(ai) s

con |B|=s y k=  p(bj/ai) · log[1/p(bj/ai)] (para algún i) j1

Máximo que se alcanza con p(ai)=1/r

Capacidad de un canal binario simétrico.- Sea el BSC

P=

b1 p q

a1 a2

b2 q p

donde q = 1-p

Como también es un canal débilmente simétrico, se aplica el resultado anterior con B={b1,b2}={0,1}, es decir, |B| = s = 2 Luego, la capacidad máxima de este canal -en bits- es s

C = log(s) - k = log(2) -  p(bj/ai) · log[1/p(bj/ai)] j1

= 1

- [ p·log(1/p) + q·log(1/q)]

(para algún i) con p(a1)=p(a2)=1/2

Es común denotar C = 1 - [ p·log(1/p) + q·log(1/q) ] de la siguiente manera: C = 1 - H(p) Ejemplo:

0.9 0.1 El BSC con matriz P =   tiene capacidad -en bits 0.1 0.9 C = 1- [0.9·log(1/0.9) + 0.1·log(1/0.1)] = 1- 0.46899559358928 = 0.53100440641072 Máximo que se alcanza con p(a1)=p(a2)=1/2

101

Algoritmo de Blahut-Arimoto.- Estima la capacidad de un canal. (adaptado del libro de Wells) Sea  un número pequeño (el error de estimación aceptado) Sea P la matriz del canal con |A|=r, |B|=s Sean p(ai) (i=1,...,r) las probabilidades de entrada Sean fi (i=1,...,r) variables auxiliares Sean p(bj) (j=1,...,s) las probabilidades de salida Algoritmo: p(ai)=1/r; r

utilizando p(bj)=  p(bj/ai)·p(ai)

calcular p(bj)

i 1

REPETIR hasta una estimación aceptable s

calcular fi = exp{



j1

p(bj/ai)·ln[p(bj/ai)/p(bj)] }

exp es la función exponencial

r

x=



i 1

fi · p(ai)

Il = log2(x) Iu = log2( max{ fi } ) Si (Iu-Il) <  C = Il STOP en otro caso p(ai) = fi · p(ai) / x calcular p(bj) finSi FIN REPETIR La capacidad estimada está en C [con las probabilidades de entrada p(ai)] Ejemplo:

0.9 0.1 Para el BSC con matriz P =    0.1 0.9 El algoritmo calcula (para = 0.00000000001) una capacidad -en bits- de C = 0.53100440641072 Y termina con p(a1)=p(a2)=0.5

102

REGLAS DE DECISIÓN PRINCIPIOS DE DECODIFICACIÓN Sea un canal con ruido de alfabeto de entrada A y alfabeto de salida B. Cuando se obtiene la salida bj (por ejemplo en un BSC se obtiene como salida un '0') el receptor debe decidir a cuál de las r entradas (a1,...,ar) corresponde esta salida. Es decir, debe decidir cuál símbolo ha enviado el emisor. Como el canal tiene ruido cuando se recibe bj (por ejemplo un 0) no necesariamente se ha enviado el mismo símbolo (en nuestro ejemplo, un 0). Una regla de decisión es una función D:B->A que asigna un único símbolo de entrada a cada símbolo de salida. Ejemplo en el caso de un BSC: - Si se recibe un 0 podemos decidir que se ha enviado (decodificarlo como) un 0 Ello puede anotarse así: D(0) = 0 - Si se recibe un 1 podemos decidir que se ha enviado (decodificarlo como) un 1 Ello puede anotarse así: D(1) = 1 Hay otras alternativas que detallamos aquí (cada regla de decisión es fija): Posible regla de decisión 1: Posible regla de decisión 2: D(0) = 0 D(1) = 0 D(0) = 0 D(1) = 1 o si lo anotamos más generalmente o si lo anotamos más generalmente D(b1) = a1 D(b2) = a1 D(b1) = a1 D(b2) = a2 Posible regla de decisión 3: Posible regla de decisión 4: D(0) = 1 D(1) = 0 D(0) = 1 D(1) = 1 o si lo anotamos más generalmente o si lo anotamos más generalmente D(b1) = a2 D(b2) = a1 D(b1) = a2 D(b2) = a2 En general, dado que a cada símbolo de salida se le puede asignar cualesquiera de los r símbolos de entrada, podemos tener rs reglas de decisión para un canal arbitrario. Está claro que cualquiera de estas reglas no hace lo correcto siempre. Pero el receptor, en su tarea de decodificación, debe utilizar alguna de ellas necesariamente. Así pues debemos elegir una de las reglas fijas de decisión. Esta elección la haremos considerando las probabilidades con las que contamos, seleccionando la más prometedora. Para optar por una regla de decisión, la construiremos asignación a asignación así: Dado j, es decir, dado el símbolo de salida bj, debemos asignarle una de las r entradas (a1,...,ar) -digamos a*- así: D(bj) = a*. La probabilidad de que esta asignación sea correcta es: p(a*/bj) Obviamente la probabilidad de que esta asignación sea incorrecta es: 1-p(a*/bj) Principio de decodificación del mínimo error.- ¿Cuál a* escribir (a1 ó a2 ... ó ar)? Podemos resolverlo a través del principio de decodificación del mínimo error (Abramson le llama de máxima posibilidad condicional y Jones del observador ideal):

103

Se elige el a*{a1,...,ar} tal que ai p(a*/bj)  p(ai/bj) Por Bayes, es equivalente decir: Se elige el a*{a1,...,ar} tal que ai p(bj/a*)·p(a*) / p(bj)  p(bj/ai)·p(ai) / p(bj) Multiplicando por p(bj) en ambos miembros, es equivalente decir: Se elige el a*{a1,...,ar} tal que ai p(bj/a*)·p(a*)  p(bj/ai)·p(ai) Es decir, se trata de maximizar el valor de p(a*/bj). Ejemplo: Sea el siguiente canal con A={a1,a2}, B={b1,b2}, p(a1)=1/2, p(a2)=1/2 0.6 0.4 P=   0.4 0.6 Construiremos la regla de decisión asignación a asignación siguiendo el principio del mínimo error: Para b1) p(b1/a1)·p(a1) = 0.6·1/2 = 0.3 p(b1/a2)·p(a2) = 0.4·1/2 = 0.2 Es claro que ai p(b1/a1)·p(a1)  p(b1/ai)·p(ai) Luego, D(b1) = a1 Para b2) p(b2/a1)·p(a1) = 0.4·1/2 = 0.2 p(b2/a2)·p(a2) = 0.6·1/2 = 0.3 Es claro que ai p(b2/a2)·p(a2)  p(b2/ai)·p(ai) Luego, D(b2) = a2 Así pues nuestra regla de decisión es: D(b1) = a1 D(b2) = a2 Nótese que para construir la regla de decisión aplicando este principio debemos tener las probabilidades p(ai). Principio de decodificación de máxima posibilidad.- Esta regla requiere que conozcamos sólo la matriz P del canal y no las probabilidades p(ai). Se elige el a*{a1,...,ar} tal que ai p(bj/a*)  p(bj/ai) Es decir, se trata de maximizar el valor de p(bj/a*). Ejemplo: Para el canal anterior, construiremos la regla de decisión asignación a asignación siguiendo el principio de máxima posibilidad: 0.6 0.4 P=   0.4 0.6 Para b1) p(b1/a1) = 0.6 p(b1/a2) = 0.4 Es claro que ai p(b1/a1)  p(b1/ai) Luego, D(b1) = a1 Para b2) p(b2/a1) = 0.4 p(b2/a2) = 0.6 Es claro que ai p(b2/a2)  p(b2/ai) Luego, D(b2) = a2 Así pues nuestra regla de decisión es: D(b1) = a1 D(b2) = a2

104

Probabilidad de que la regla de decisión sea correcta y probabilidad de error de la regla de decisión.- Se calculan de la misma manera para reglas de decisión provenientes de ambos principios de decodificación: s

La probabilidad de que la regla de decisión sea correcta es: PC =  p(a*/bj)·p(bj) j1

La probabilidad de error de la regla de decisión así elegida es: O bien, s s PE = 1 - PC PE =  [1-p(a*/bj)]·p(bj) =  [p(bj)-p(a*/bj)·p(bj)] j1 s

j1

s

=  p(bj)-  p(a*/bj)·p(bj) j1

s

= 1 -  p(a*/bj)·p(bj)

= 1 -  p(a*/bj)·p(bj)

j1

j1

r

como s

PE = 

j1

s

  i 1

j1

r



i 1

j1

s

p(ai,bj) = s

p(ai,bj) -



j1

s

r

j1

i 1

 

p(ai,bj) =1 s

p(a*/bj)·p(bj) = 

j1

(algunos autores lo escriben así) =  B

r



i 1

s

p(ai,bj) -





j1

p(a*,bj)

p(ai,bj)

A - {a*}

(a* se elige según la regla de decisión, para cada bj) Ejemplo: Para el canal anterior, ambos principios de decodificación ofrecen la siguiente regla: D(b1) = a1 D(b2) = a2 Además: p(a1,b1) = p(b1/a1)·p(a1) = 0.6·1/2 = 0.3 p(a1,b2) = p(b2/a1)·p(a1) = 0.4·1/2 = 0.2 p(a2,b1) = p(b1/a2)·p(a2) = 0.4·1/2 = 0.2 p(a2,b2) = p(b2/a2)·p(a2) = 0.6·1/2 = 0.3 Luego: s

PE = 

j1

r



i 1

s

p(ai,bj) -



j1

p(a*,bj) = 0.3 + 0.2 + 0.2 + 0.3 - [0.3 + 0.3] = 0.4

Los principios de decodificación de máxima posibilidad y del mínimo error son equivalentes cuando las probabilidades p(ai) son iguales.En efecto, el principio de decodificación del mínimo error es el siguiente: Se elige el a*{a1,...,ar} tal que ai p(bj/a*)·p(a*)  p(bj/ai)·p(ai) De acuerdo a nuestro supuesto los p(ai) son iguales, obviamente también es igual p(a*). Cancelando estos términos en la última expresión, se tiene: Se elige el a*{a1,...,ar} tal que ai p(bj/a*)  p(bj/ai) Que es exactamente el principio de máxima posibilidad.

105

Cuando hay más de una alternativa equivalente se elige cualquiera de ellas. Ejemplo: Sea el siguiente canal con A={a1,a2}, B={b1,b2}, p(a1)=1/2, p(a2)=1/2 0.5 0.5 P=   0.5 0.5 Siguiendo el principio del mínimo error para b1: Siguiendo el principio de máxima posibilidad para b1: p(b1/a1)·p(a1) = 0.5·1/2 = 0.25 p(b1/a2)·p(a2) = 0.5·1/2 = 0.25 Es claro que la condición ai p(b1/a1)·p(a1)  p(b1/ai)·p(ai) cumple y ai p(b1/a2)·p(a2)  p(b1/ai)·p(ai)

p(b1/a1) = 0.5 p(b1/a2) = 0.5 Es claro que la condición ai p(b1/a1)  p(b1/ai) y ai p(b1/a2)  p(b1/ai)

se

se cumple también

también

Luego, a b1 se le puede asignar tanto a1 Luego, a b1 se le puede asignar tanto a1 como a2. como a2. Elegimos: D(b1) = a1 Elegimos: D(b1) = a1 El principio de máxima posibilidad no garantiza mínimizar la probabilidad de error de la regla de decisión -para el caso en que los p(ai) no sean iguales-. Ejemplo: Sea el siguiente canal con A={a1,a2}, B={b1,b2}, p(a1)=1/10, p(a2)=9/10 0.7 0.3 P=   0.3 0.7 Por el principio del mínimo error Por el principio de máxima posibilidad b1) Como: p(b1/a1)·p(a1) = 0.7·1/10 = 0.07 b1) Como: p(b1/a1) = 0.7 p(b1/a2)·p(a2) = 0.3·9/10 = 0.27 p(b1/a2) = 0.3 Es claro que ai p(b1/a2)·p(a2)  p(b1/ai)·p(ai) Es claro que ai p(b1/a1)  p(b1/ai) Luego, D(b1) = a2 Luego, D(b1) = a1 b2) Como: p(b2/a1)·p(a1) = 0.3·1/10 = 0.03 b2) Como: p(b2/a1) = 0.3 p(b2/a2)·p(a2) = 0.7·9/10 = 0.63 p(b2/a2) = 0.7 Es claro que ai p(b2/a2)·p(a2)  p(b2/ai)·p(ai) Es claro que ai p(b2/a2)  p(b2/ai) Luego, D(b2) = a2 Luego, D(b2) = a2 Resumiendo: D(b1) = a2

D(b2) = a2

Resumiendo: D(b1) = a1

D(b2) = a2

Como: p(a1,b1) = p(b1/a1)·p(a1) = 0.7·1/10 = 0.07 p(a1,b2) = p(b2/a1)·p(a1) = 0.3·1/10 = 0.03 p(a2,b1) = p(b1/a2)·p(a2) = 0.3·9/10 = 0.27 p(a2,b2) = p(b2/a2)·p(a2) = 0.7·9/10 = 0.63 s

Y sabiendo que:

PE = 

j1

r



i 1

s

p(ai,bj) -



j1

p(a*,bj)

PE = 0.07 + 0.03 + 0.27 + 0.63 - [0.27 + 0.63] PE = 0.07 +0.03+0.27 +0.63 -[0.07+ 0.63] = 0.1 = 0.3 ( > 0.1 )

106

EL SEGUNDO TEOREMA DE SHANNON TEOREMA FUNDAMENTAL DE LA CODIFICACIÓN (en canales con ruido) Cómo manipular un canal para hacerlo más confiable.- Mostraremos en base a un ejemplo clásico que, a pesar del ruido, un canal puede utilizarse de manera relativamente más confiable mediante algunas modificaciones. Ejemplo: Sea el siguiente canal con A={a1,a2}, B={b1,b2}, p(a1)=1/2, p(a2)=1/2  p q P=  con p > 0.5; dado que p + q = 1 es claro que q < 0.5; y que p > q   q p Como p(a1)=p(a2)=1/2, los principios de decodificación de máxima posibilidad y del mínimo error son equivalentes. Construyamos la regla de decisión según el principio de máxima posibilidad: b1) Como: p(b1/a1) = p p(b1/a2) = q p>q Es claro que ai p(b1/a1)  p(b1/ai) Luego, D(b1) = a1 b2) Como: p(b2/a1) = q p(b2/a2) = p p>q Es claro que ai p(b2/a2)  p(b2/ai) Luego, D(b2) = a2 Es decir, la regla de decisión es: D(b1) = a1

D(b2) = a2

Como: p(a1,b1) = p(b1/a1)·p(a1) = p·1/2 = p/2 p(a1,b2) = p(b2/a1)·p(a1) = q·1/2 = q/2 p(a2,b1) = p(b1/a2)·p(a2) = q·1/2 = q/2 p(a2,b2) = p(b2/a2)·p(a2) = p·1/2 = p/2 La probabilidad de error de nuestra regla de decisión es: s

PE = 

j1

r



i 1

s

p(ai,bj) -



j1

p(a*,bj) = p/2 + q/2 + q/2 + p/2 - [p/2 + p/2] = q

Manipulación sugerida: A partir del canal que tenemos, ingeniosamente crearemos otro canal según la siguiente idea: en vez de enviar un 0 ó un 1, repetiremos el envío tres veces, es decir, las entradas serán ahora a1=000 o bien a2=111. Como se trata del mismo canal de base, los tres símbolos de una u otra entrada pueden verse afectados por el ruido, así pues las salidas posibles serán (fíjese bien el orden): b1=000, b2=001, b3=010, b4=100, b5=011, b6=101, b7=110, b8=111. Es posible calcular p(bj/ai) en términos de las probabilidades del canal original así: Sean bj=bj1...bjn y ai=ai1...ain, entonces p(bj/ai) = p(bj1/ai1) · ... · p(bjn/ain).

107

p(b1/a1) = p(000/000) = p(0/0) · p(0/0) · p(0/0) = p·p·p = p3 p(b2/a1) = p(001/000) = p(0/0) · p(0/0) · p(1/0) = p·p·q = p2q El resto de los casos se resume en la siguiente matriz: b1=000 b2=001 b3=010 b4=100 b5=011 b6=101 b7=110 b8=111 a1=000 p3 p2q p2q p2q pq2 pq2 pq2 q3 a2=111 q3 pq2 pq2 pq2 p2q p2q p2q p3 Así pues:

Nótese que p(a1)=p(a2)=1/2 (otras entradas no se envían), de manera que los principios de decodificación de máxima posibilidad y del mínimo error son equivalentes. Construyamos la regla de decisión según el principio de máxima posibilidad: Previamente, dado que p > q, es claro que: p3 > q3 y que p2q > pq2 b1) Como: p(b1/a1) = p3 p(b1/a2) = q3 Es claro que ai p(b1/a1)  p(b1/ai) Luego, D(b1) = a1 b2) Como: p(b2/a1) = p2q p(b2/a2) = pq2 Es claro que ai p(b2/a1)  p(b2/ai) Luego, D(b2) = a1 Los otros resultados se obtienen de manera semejante. La nueva regla de decisión es: D(b1) = a1 D(b2) = a1 D(b3) = a1 D(b4) = a1 D(b5) = a2 D(b6) = a2 D(b7) = a2 D(b8) = a2 Que indica, por ejemplo: si se recibe b5=011, debe asignársele (debe deducirse que se ha enviado) a2=111, que codifica al 1, es decir, se deduce que se ha enviado un 1. En general, la regla indica que debemos deducir que se ha enviado 000 (que codifica al 0) si hay mayor cantidad de ceros en bj, o bien 111 (que codifica al 1) en caso contrario. Por otro lado, como: p(a1,b1) = p(b1/a1)·p(a1) = p3·1/2 = p3/2 p(a1,b2) = p(b2/a1)·p(a1) = p2q·1/2 = p2q/2 p(a1,b3) = p(b3/a1)·p(a1) = p2q·1/2 = p2q/2 p(a1,b4) = p(b4/a1)·p(a1) = p2q ·1/2 = p2q/2 p(a1,b5) = p(b5/a1)·p(a1) = pq2·1/2 = pq2/2 p(a1,b6) = p(b6/a1)·p(a1) = pq2·1/2 = pq2/2 p(a1,b7) = p(b7/a1)·p(a1) = pq2·1/2 = pq2/2 p(a1,b8) = p(b8/a1)·p(a1) = q3·1/2 = q3/2

p(a2,b1) = p(b1/a2)·p(a2) = q3·1/2 = q3/2 p(a2,b2) = p(b2/a2)·p(a2) = pq2·1/2 = pq2/2 p(a2,b3) = p(b3/a2)·p(a2) = pq2·1/2 = pq2/2 p(a2,b4) = p(b4/a2)·p(a2) = pq2·1/2 = pq2/2 p(a2,b5) = p(b5/a2)·p(a2) = p2q·1/2 = p2q/2 p(a2,b6) = p(b6/a2)·p(a2) = p2q·1/2 = p2q/2 p(a2,b7) = p(b7/a2)·p(a2) = p2q ·1/2 = p2q/2 p(a2,b8) = p(b8/a2)·p(a2) = p3·1/2 = p3/2

La probabilidad de error de nuestra nueva regla de decisión es: s

PE = 

j1

r



i 1

s

p(ai,bj) -



j1

p(a*,bj) = 3pq2/2 + q3/2 + q3/2 + 3pq2/2 = 3pq2 + q3

Lo importante de resaltar aquí es que si q es un valor pequeño: 3pq2 + q3 < q. Por ejemplo, para q=0.02 tenemos que p=0.98 y por lo tanto 3pq2 + q3= 0.001184 Es decir, codificar 0 como 000 y 1 como 111, repitiendo tres veces el envío, reduce la probabilidad de error en nuestra regla de decisión: hace más confiable el canal.

108

Velocidad del código (code rate).- El precio de reducir la probabilidad de error de la regla de decisión (es decir, menor error en la decodificación), es que -para el mismo mensaje- ya no se envía un símbolo a1=0 (o a2=1) sino una secuencia de tres símbolos 000 (o 111), denotado en el nuevo canal como a1 (o a2). Ello significa un mayor costo. En general, se define la velocidad del código como: R = Hr(S)/n S: es la fuente de los mensajes Hr(S): es la entropía de dicha fuente (número medio de r-its de información transmitidos con cada mensaje) n: es el largo de la secuencia para representar los mensajes (finalmente será la longitud de las palabras (código) que representan los mensajes) En el ejemplo que estamos manejando: Para las transmisiones a través del canal original: A = { a1, a2 }= { 0, 1 } con p(a1) = 1/2 y p(a2) = 1/2 H(A) = log22 = 1 bit n=1 Para enviar un bit de información utilizamos una secuencia de un símbolo. Luego, la velocidad del código es: R = 1/1 =1 Para las transmisiones a través del canal con la manipulación: A = { a1, a2 }= { 000, 111 } con p(a1) = 1/2 y p(a2) = 1/2 H(A) = log22 = 1 bit n=3 Para enviar un bit de información utilizamos una secuencia de tres símbolos. Luego, la velocidad del código es R = 1/3 Así pues, aunque en la manipulación el error en la decodificación es menor, la velocidad del código también es menor. Si en vez de tres repeticiones, pensamos en cinco, siete, etc., es intuitivo imaginar que la probabilidad de error de la regla de decisión será aún menor; lamentablemente la velocidad del código también (PE->0 cuando n->; pero también R->0 cuando n->). De esta manera, R representa la cantidad relativa de información transportada en cada secuencia de símbolos. Lo ideal será utilizar una longitud de bloque pequeña para transmitir mucha información. Lo contrario, utilizar muchos símbolos para transportar poca información, es decir, una velocidad del código próxima a cero, es completamente indeseable (muchos símbolos que informan muy poco).

Hay un otro componente a tomar en cuenta, se trata de la Capacidad del canal. No podemos desbordar esta capacidad, pero tampoco podemos desaprovecharla con una velocidad del código (R) muy baja.

109

En nuestro ejemplo, dado que se trata de un BSC, sabemos que (ver página 101): C = 1 - [ p·log(1/p) + q·log(1/q) ] = 1 - H(p) H(A) = log22 = 1 bit El mensaje a1=0 se lo codifica como a1=000 El mensaje a2=1 se lo codifica como a2=111 n=3 R = 1/3 = 0.333 Por ejemplo con p = 0.9 se tiene H(p) = 0.469 y C = 0.531, es decir, R
El segundo teorema de Shannon vislumbra que tal manipulación no se limita a la repetición y por lo tanto, si lo hacemos más hábilmente, utilizando reglas de decisión apropiadas aunque recurramos a secuencias más largas para codificar los mismos mensajes: es posible pensar en un código canal de manera tal que PE->0 pero con la velocidad del código (R) todo lo cerca que se quiera de la capacidad (C) del canal. Lo enunciamos aquí, sin demostración, en su versión para canales binarios simétricos. Teorema Fundamental de la Codificación.- Sea un BSC de matriz  p q P=  con p > 0.5 y cuya capacidad del canal es C = 1 - H(p)   q p Sean >0 y >0. Entonces, para n suficientemente largo, existe un código canal C, binario y bloque -de longitud n-, cuya velocidad del código es R, que satisface C-  R
110

PRINCIPIO DE DECODIFICACIÓN DE MÍNIMA DISTANCIA (ó MÁXIMA VECINDAD) DE HAMMING Ya vimos que -a partir de un canal base, un BSC por ejemplo- de entradas ai y salidas bj, podemos considerar otro canal de entradas ai y salidas bj que son secuencias de símbolos del canal original. A partir de ahora trabajaremos bajo dichas condiciones. Más aún, los ai serán de igual longitud -es decir bloque-. Generalmente trabajaremos con secuencias de 0's y 1's (algo semejante sucede con los bj). Recordemos que es posible calcular p(bj/ai) en términos de las probabilidades del canal original así: Sean bj=bj1...bjn y ai=ai1...ain, entonces p(bj/ai) = p(bj1/ai1) · ... · p(bjn/ain) Ejemplo (del libro de Togneri): Sea un BSC de matriz 0.6 0.4 P=   donde A={a1,a2}={0,1}; B={b1,b2}={0,1} 0.4 0.6 Consideremos el siguiente otro canal con A={a1,a2,a3,a4}={000,011,101,110} B={b1,b2,b3,b4,b5,b6,b7,b8}={000,001,010,011,100,101,110,111} Cada celda de la matriz puede calcularse así: p(b1/a1) = p(000/000) = p(0/0) · p(0/0) · p(0/0) = 0.6 · 0.6 · 0.6 = 0.216 El resto es: b1=000 b2=001 b3=010 b4=011 b5=100 b6=101 b7=110 b8=111 a1=000 0.216 0.144 0.144 0.096 0.144 0.096 0.096 0.064 a2=011 0.096 0.144 0.144 0.216 0.064 0.096 0.096 0.144 a3=101 0.096 0.144 0.064 0.096 0.144 0.216 0.096 0.144 a4=110 0.096 0.064 0.144 0.096 0.144 0.096 0.216 0.144 Podemos construir la regla de decisión aplicando el principio de máxima posibilidad. Dicho principio es: Se elige el a*{a1,...,ar} tal que ai p(bj/a*)  p(bj/ai) Nótese que dado un bj, dicha regla se reduce a elegir un a*=ai correspondiente al mayor valor en la columna j (cualquiera de ellos, si hay más de uno). Luego, la regla de decisión es: D(b1)=a1 D(b2)=a3 D(b3)=a4 D(b4)=a2 D(b5)=a1 D(b6)=a3 D(b7)=a4 D(b8)=a2 Distancia de Hamming.- Sean a=a1...an y b=b1...bn dos cadenas de longitud n. La distancia de Hamming entre a y b, denotada por d(a,b) se define como el número de posiciones en las que difieren dichas cadenas a y b. Ejemplos: a = 00010 a = 1111 a=1 a = 010 a = 01101 b = 00000 b = 1111 b=0 b = 101 b = 10110 d(a,b) = 1 d(a,b) = 0 d(a,b) = 1 d(a,b) = 3 d(a,b) = 4

111

Es claro que dos cadenas a,b de igual longitud, pueden diferir en cero posiciones -si son iguales-, o en una, en dos, etc. Es decir, d(a,b)  0. También es claro que el número de posiciones en las que difieren las cadenas a y b, es el mismo número en las que difieren las cadenas b y a. Es decir, d(a,b) = d(b,a). Ahora, probaremos que dadas las cadenas a,b,c de igual longitud: d(a,c)  d(a,b) + d(b,c). Propiedad conocida como la desigualdad del triángulo. En efecto, mostraremos previamente que: (1) Si aici entonces (aibi ó bici). Demostración: La contrarrecíproca del enunciado es: Si (aibi o bici) entonces (aici) Es decir, Si ai=bi y bi=ci entonces ai=ci Que es verdadera por simple inspección (transitividad de la relación de igualdad). Consideremos cadenas de un sólo símbolo, es decir, cadenas cuya distancia de Hamming sea 0 (cuando son iguales, es decir, cuando son el mismo símbolo) o 1 (cuando son diferentes -símbolos-). Probaremos que: (2) d(ai,ci)  d(ai,bi) + d(bi,ci) Demostración: Por reducción al absurdo, supongamos que d(ai,ci) > d(ai,bi) + d(bi,ci) Ello puede suceder sólo de la siguiente manera: 1 > 0 + 0 Es decir, cuando aici y cuando ai=bi y bi=ci. Pero (1) muestra que si aici entonces (aibi ó bici). Esta contradicción muestra que nuestro supuesto está errado y prueba el enunciado. Es obvio que la distancia entre dos cadenas -a,b por ejemplo-, es la suma de las distancias entre cada uno de sus símbolos (posición a posición). Es decir: (3) d(a,b) = d(a1,b1) + ... + d(an,bn) (4) Recordemos que: Si x  z y t  s Entonces x+t  z+s. Finalmente, sean a,b,c cadenas de longitud n. Por (2) sabemos que: d(a1,c1)  d(a1,b1) + d(b1,c1) ... d(an,cn)  d(an,bn) + d(bn,cn) Y por (3) y (4) resulta que: d(a,c)  d(a,b) + d(b,c) Que es lo que queríamos demostrar. Colocando juntas las tres condiciones: i) d(a,b)  0 ii) d(a,b) = d(b,a) iii) d(a,c)  d(a,b) + d(b,c)

112

Principio de decodificación de mínima distancia (ó máxima vecindad) de Hamming.Se elige el a*{a1,...,ar} tal que ai d(a*,bj)  d(ai,bj) Es decir, se trata de minimizar el valor de d(a*,bj). Ejemplo: Recordemos que en nuestro último caso A={a1,a2,a3,a4}={000,011,101,110} B={b1,b2,b3,b4,b5,b6,b7,b8}={000,001,010,011,100,101,110,111} Supongamos que recibimos b7=110 d(a1,b7)=d(000,110)=2 d(a2,b7)=2 d(a3,b7)=2 d(a4,b7)=0 De manera que nuestra regla de decisión incluirá: D(b7)=a4 El resto se hace de manera semejante (en caso de varias alternativas equivalentes, se elige cualquiera). La regla de decisión es: D(b1)=a1 D(b2)=a3 D(b3)=a4 D(b4)=a2 D(b5)=a1 D(b6)=a3 D(b7)=a4 D(b8)=a2

El principio de decodificación de mínima distancia de Hamming´es el mismo que el de máxima posibilidad, para un BSC como canal base.Sean A={0,1}; B={0,1} y un BSC de matriz  p q P=  con p > 0.5; dado que p + q = 1 es claro que q < 0.5; y que p > q   q p Supongamos un otro canal -construido a partir de él- con A={a1, ... ,ar} B={b1, ... ,b2n} Las entradas y salidas ai,bj tienen la misma longitud n. Consideremos que se envía ai=ai1...ain y se recibe bj=bj1...bjn. Supongamos que d(ai,bj) = t. Es decir, t es el número de bits invertidos o errados entre lo que envía y lo que se recibe. Como la probabilidad de error es q y la probabilidad de certeza es p : p(bj/ai) = p(bj1/ai1) · ... · p(bjn/ain) = qt · pn-t Recordemos que bajo el principio de decodificación de máxima posibilidad se trata de maximizar el valor de p(bj/a*). ¿ Para cuál ai se maximiza el valor de p(bj/ai) = qt · pn-t ? Dado que p(bj/ai) = qt · pn-t = qt · pn · p-t = qt · pn · 1/pt = (q/p)t · pn Como p > q es claro que (q/p) < 1. Luego, (q/p)t se maximiza cuando t es mínimo. Y como pn es fijo, p(bj/ai) = (q/p)t · pn se maximiza cuando t es mínimo. Es decir, al minimizar t = d(ai,bj), se maximiza p(bj/ai): luego, los principios de decodificación de máxima posibilidad y mínima distancia de Hamming son iguales. Cuando además las probabilidades de entrada p(ai) son equivalentes, el principio del mínimo error también es el mismo. Así pues, bajo las condiciones anteriores, para construir la regla de decisión, ya no es necesario efectuar tantos cálculos [la matriz del nuevo canal con p(bj/ai) para cada i,j y luego buscar p(bj/a*)] sino apelar a la distancia de Hamming, buscando la menor. Como ilustramos antes con un ejemplo.

113

En general suponiendo que se recibe bj: i) Si bj=ai, para algún i, entonces asignamos a*=ai (cuando se recibe algo -sin bits errados- que corresponda a una entrada lícita, se deduce que eso es precisamente lo que se ha enviado). ii) Si i bjai, entonces se le asigna a a* la entrada que diste menos de la salida bj, es decir, tal que ai d(a*,bj)  d(ai,bj) (cuando se recibe algo -con bits errados- que no corresponde a ninguna entrada lícita, se deduce que lo que se ha enviado es la entrada más vecina (cercana) a eso que se recibe, en el sentido de Hamming). Obviamente, siempre existe una probabilidad de error. Por ejemplo, supongamos que a1=000 y que a2=111. Supongamos que se envía a2=111. Y que se recibe b1=000: los tres bits se han invertido por el ruido. La probabilidad de ello es p(b1/a2) = p(000/111) = p(0/1) · p(0/1) · p(0/1) = q · q · q = q3 (para q=0.4, q3=0.064) Nuestra regla de decisión es D(b1)=a1, pues d(a1,b1)=0. Deduciendo -incorrectamente- que se ha enviado a1.

114

CÓDIGOS DETECTORES Y CORRECTORES Aunque se utilice un BSC donde finalmente se envían ceros y/o unos, lo que en general se desea envíar son mensajes ai. Por ejemplo a1=0 o, lo que es más usual, mensaje más largos por ejemplo a1=1000001 (=65 el código ascii de la 'A'). Ya vimos que una forma de manipular el canal y hacerlo más confiable eludiendo el ruido, es no enviar los mensajes originales sino añadirles algún(os) bit(s) de redundancia. Por ejemplo en vez de un 0 representarlo con la entrada a1=000; o en nuestro segundo ejemplo en vez de 1000001 representarlo con la entrada a1=10000010 (donde hemos subrayado el bit de redundancia añadido). Obviamente las salidas todavía pueden verse afectadas por el ruido. Sin embargo, con principios de decodificación apropiados (como el de la mínima distancia de Hamming) pueden construirse reglas de decisión cuya probabilidad de error sea disminuida: tanto por la redundancia como por lo pertinente de la regla. Códigos (del) canal.- Al hecho de aumentar bits de redundancia a los mensajes, haciendo más largas las entradas (para transmitir los mismos mensajes) pero más resistentes al ruido, le llamaremos: la construcción de un código (del) canal. Bajo el principio de decodificación de la mínima distancia de Hamming, es deseable que pensemos en construir códigos canal tales que: Si i bjai Entonces al asignar a a* la entrada que diste menos de la salida bj, no haya más de una alternativa. En cuyo caso, si d(a*,bj)=t, estaríamos corrigiendo los t errores. Este es el esquema FEC por las siglas en inglés de Forward Error Correction. En cambio, cuando para la salida bj, hay varias entradas ai que están igual de cercanas, d(a*,bj)=t para estas varias entradas ai: una postura considera que es mejor no elegir cualquiera de dichas alternativas, sino solamente indicar que se han detectado t errores, solicitando un reenvío. Este es el esquema ARQ, por las siglas en inglés de Automatic Repeat Request. Un buen código canal C, debe permitir detectar todos los t errores, donde sea que ocurran y en cualquier palabra código que ocurran. Mejor aún será que se corrijan tales errores.. Será más complejo construir un código canal C a medida que t aumenta (1, 2, etcétera). Por fortuna, dependiendo del canal y del valor de q, en general un valor alto para t -dentro de una palabra código-, es decir, una cantidad alta de errores tiende a ser más improbable. Distancia mínima de un código canal.- Sea C={a1, ... ,aM} un código canal. Denotaremos por dC a la distancia mínima de C definida así: dC = min { d(ai,aj) / ai,aj  C; ij } Ejemplo:Sea C={a1,a2,a3,a4}={000,011,101,110} dC = min { d(ai,aj) / ai,aj  C; ij } = min {d(a1,a2), d(a1,a3), d(a1,a4), d(a2,a3), d(a2,a4), d(a3,a4)} = min { 2, 2, 2, 2, 2, 2 } =2

115

C detecta t errores si y sólo si dC > t Demostración: Supongamos que se ha enviado a* y se ha recibido bj. Asumamos que hay t errores, es decir, d(a*,bj)=t (t > 0)

(1)

Por la desigualdad del triángulo se cumple que: aiC-{a*} d(a*,bj) + d(bj,ai)  d(a*,ai) Luego, aiC-{a*} d(bj,ai)  d(a*,ai) - d(a*,bj)

(2)

Para que el receptor detecte que bj tiene errores, es suficiente que no coincida con ninguna palabra código. Es decir, que: i) aiC-{a*} d(ai,bj)>0, o equivalentemente, aiC-{a*} d(bj,ai) > 0 (3) ii) Ya se sabe, por (1), que d(a*,bj)>0. Para asegurar (3) debemos tener -por (2)- que: aiC-{a*} d(a*,ai) - d(a*,bj) > 0 Es decir, aiC-{a*} d(a*,ai) > d(a*,bj) Que por (1) es aiC-{a*} d(a*,ai) > t Lo cual es cierto si y sólo si dC > t. Que es lo que queríamos demostrar. Dado que dC > t puede escribirse como dC  t+1 y también como dC-1  t, es usual utilizar este resultado para determinar cuántos errores puede detectar el código C, siendo la respuesta dC-1 errores. C corrige t errores si y sólo si dC > 2t Demostración: Supongamos que se ha enviado a* y se ha recibido bj. Asumamos que hay t errores, es decir, d(a*,bj)=t

(i)

Por la desigualdad del triángulo se cumple que: aiC-{a*} d(a*,bj) + d(bj,ai)  d(a*,ai) Luego, aiC-{a*} d(bj,ai)  d(a*,ai) - d(a*,bj)

(ii)

Para que el receptor detecte que bj tiene errores y asegurar que la regla de máxima vecindad nos dirige hacia a* (y así corregir lo errado), es suficiente que: aiC-{a*} d(ai,bj) > d(a*,bj) (iii) Para asegurar (iii) debemos tener -por (ii)- que: aiC-{a*} d(a*,ai) - d(a*,bj) > d(a*,bj) Es decir, aiC-{a*} d(a*,ai) > d(a*,bj) + d(a*,bj) Es decir, aiC-{a*} d(a*,ai) > 2·d(a*,bj) Que por (i) es aiC-{a*} d(a*,ai) > 2·t Lo cual es cierto si y sólo si dC > 2t. Que es lo que queríamos demostrar. Dado que dC > 2t puede escribirse como dC  2t+1 y también como [dC-1]/2  t, es usual utilizar este resultado para determinar cuántos errores puede corregir el código C, siendo la respuesta [dC-1]/2 errores.

116

Estandarización de las entradas.- Ejemplo: Sea una fuente con alfabeto S={s1,s2} y código asociado C={0,10,11}. Nótese que dicho código de Huffman no es bloque. Al mensaje s1s1s1s2s1s2 le corresponde la secuencia 00011011, que puede separarse en bloques de dos símbolos así: 00 01 10 11. A partir de ahora, adoptaremos este modo de proceder de manera que, independientemente de la fuente y de los mensajes a emitirse, segmentaremos la entrada al canal en bloques de longitud k. De esta manera -aún cuando partamos de un BSC- consideraremos que las preentradas a'i al canal son todas las 2k secuencias de símbolos de longitud k. Dado que estas secuencias no corresponden necesariamente a los símbolos de la fuente, podemos además asumir que son equiprobables. Si bien estas secuencias no corresponden necesariamente a los símbolos de la fuente, aún así las llamaremos mensajes, pues son estas secuencias las que contienen los mensaje que se quieren transmitir. Nótese que hemos utilizado a'i (a prima sub i). En efecto, hasta ahora sólo hemos agrupado en bloques de longitud k, las secuencias correspondientes a los mensajes a transmitirse. Falta aún la imprescindible tarea de extender la longitud de estos bloques, añadiendo bits de redundancia con el propósito de que estas entradas, así manipuladas, nos permitan eludir el ruido. Finalmente las entradas ai, que son las que realmente serán transmitidas, son bloques de longitud N (con N>k). Los N-k bits de redundancia (añadidos a los k bits que constituyen los mensajes a transmitirse) deben construirse de tal manera que siendo los menos posibles puedan corregir (o detectar) la mayor cantidad de errores. Tal como se ha planteado la segmentación -en bloques de longitud k-, asumiremos que hay M=2k bloques a'i [eventualmente cada uno con probabilidad p(a'i)=1/2k]. Cada una de estos M mensajes (de longitud k) debe completarse con (r=N-k) bits de redundancia, para conformar una palabra código ai (de longitud N) del código canal en construcción [eventualmente cada una con probabilidad p(ai)=1/2k, esto es equiprobables]. Queda claro que las salidas bj tendrán longitud N también. De las 2N secuencias posibles, sólo M=2k corresponden a palabras código enviadas (las reuniremos en el conjunto BM). Las otras no son palabras código (las reuniremos en el conjunto B'M). Será la regla de decisión que adoptemos -por ejemplo a través del principio de la mínima distancia de Hamming- la que, en el mejor de los casos, determine cuáles bits están errados y los corrija. Ejemplo: Independientemente de la fuente original y su código asociado (de Huffman por ejemplo, el cual no es necesariamente bloque), cualquier segmentación de los mensajes originales trabajará con las siguientes pre-entradas A'={a'1,a'2,a'3,a'4}={00,01,10,11} de longitud k=2. A partir de ellas, construiremos un código con palabras de longitud N=4. Los r=N-k=2 bits de redundancia se añaden como sigue (los hemos subrayado): C={0000,0101,1010,1111} cuya dC = 2 En realidad no es necesario que los bits de redundancia vayan al final (juntos).

117

El problema central ahora es: a partir de las pre-entradas a'i de longitud k, dónde y cuáles r bits de redundancia añadir al construir las palabras del código canal; y qué valor exactamente tendrá r (ó, sabiendo que r=N-k, qué valor le asignaremos a N). Obviamente, debemos explicitar una regla de decisión (a través del principio de la mínima distancia de Hamming por ejemplo). Anteriores resultados, nos permiten verificar cuántos errores puede corregir nuestro código canal. Adicionalmente presentaremos el siguiente resultado: La probabilidad de decodificación errónea siguiendo el principio de mínima distancia de Hamming en un código bloque C de longitud N, puede calcularse fácilmente si tenemos la distancia mínima de C (que es como si tuviéramos t, y viceversa). Se supone que hay un BSC como base cuya probabilidad de error es q. t  N Si C corrige t errores Entonces PE(C) = 1 -    qt·pN-t i 0  i  Demostración: La probabilidad de que t bits estén errados en una palabra es qt (y que los otros N-t sean correctos es pN-t). Pero estos t bits errados pueden estar en cualquier lugar de las N posiciones posibles, así pues, la probabilidad de que t bits estén errados en una palabra debe considerar estas combinaciones de N tomados de a t. Así, la probabilidad de que t  N bits estén errados en una palabra de longitud N es:   qt·pN-t t Como C corrige t errores, en realidad puede corregir hasta t errores, de manera que la probabilidad de que la decodificación sea correcta es la probabilidad de que hayan 0 errores (que no hay necesidad de corregir), que haya 1 error (que C corrige), que hayan t  N dos errores (que C corrige), y así hasta t errores, es decir: Pc(C) =    qt·pN-t i 0  i  t  N Luego, la probabilidad de decodificación errónea es: PE(C) = 1 - Pc(C) = 1 -    qt·pN-t i 0  i 

Empezaremos a obtener algunos resultados previos con miras a determinar el valor de r: V(N,t).- Denotaremos con V(N,t) al número de palabras de longitud N cuya distancia a la palabra código a* es menor o igual que t. Es decir, cuya distancia con a* es t, ó t-1, ... , ó 0. Probaremos que: t  N V(N,t) =    i 0  i  Demostración: Recordemos que las palabras en consideración tienen longitud N. Por definición, d(a*,bj) = i si y sólo si bj difiere de a* en i posiciones. Sea bj  (BM B'M), es decir, bj es cualquiera de las 2N palabras posibles de longitud N. De ellas: ¿ Cuántas difieren de a* en i=0 posiciones ?  N Respuesta: 1=   [sólo la misma palabra] 0

118

¿ Cuántas difieren de a* en i=1 posición ? Respuesta: La posición que difiere puede ser la primera, la segunda, etc.  N N=   1 ¿ Cuántas difieren de a* en i=2 posiciones ? Respuesta: La dos posiciones puede ser las dos primeras, las dos segundas, ..., las dos últimas; pero también cualquier otra combinación como la primera y la tercera, la segunda y la última, etc. Es decir, cualquier combinación de N tomados de a 2, sin repetición, es decir:  N N=   2 Etcétera. En general, como las i posiciones pueden suceder en cualquiera de los N posibles lugares,  N es claro que hay:   palabras bj que difieren i posiciones de a*. i t  N Luego, V(N,t) =    . i 0  i  Límite de Hamming.- Si el código canal C de longitud N corrige t errores Entonces el número M de palabras código de C debe ser tal que M  2N / V(N,t). Demostración: 1) Como C corrige t errores, sabemos que dC > 2t, es decir, para cualesquier dos palabras código ai,aj se tiene que d(ai,aj)>2t. Ello significa que no hay una palabra bj que diste t -o menos- de dos palabras código (o tres, o más). Pues en ese caso, dichas palabras código estarían muy cerca entre sí, contradiciendo que d(ai,aj)>2t. Otra forma de decirlo es que ninguna palabra bj dista t (o menos) de más de una palabra código. 2) Sabemos que el número de palabras de longitud N, que disten t -o menos- de la palabra código a* es: V(N,t) (esto es para una palabra código, en particular a*). Consideremos ahora todas las palabras código ai. El número de palabras de longitud N, cuya distancia a cualquiera de las M=2k palabras código ai sea menor o igual que t es: M·V(N,t). 3) Sólo hay 2N palabras posibles de longitud N. Supongamos que M·V(N,t) > 2N. La única forma de que ello suceda es que, en el producto M·V(N,t), algunas o varias palabras de longitud N se cuenten más de una vez. Y la única forma de que ello suceda, es cuando dichas palabras disten t (o menos) de más de una palabra código. Lo que contradice 1). Así pues el supuesto es erróneo. De manera que, para garantizar que ninguna palabra esté a una distancia t -o menos- de más de una palabra código, debe suceder que: M·V(N,t)  2N Que es precisamente lo que queríamos probar Como M=2k, podemos reescribir M·V(N,t)  2N así: 2k·V(N,t)  2N Y aplicando logaritmos: k + log2[V(N,t)]  N Es decir: log2[V(N,t)]  N-k Es decir, log2[V(N,t)]  r

119

Así, los r=N-k bits de redundancia que deben añadirse son, por lo menos: log2[V(N,t)]. Si nos fijamos el enunciado del límite de Hamming, es claro que esta es una condición necesaria (para la existencia y construcción de un código C que corrija t errores), no suficiente. Código maximal.- El código canal C de longitud N y distancia mínima dC se dice maximal si tiene el mayor número de palabras código. Es decir, si no existe otro código de longitud N con la misma distancia mínima que tenga más palabras código. Ejemplo: Sea N=3 y trabajemos con el alfabeto X={0,1} Todas las palabras de longitud N=3 posibles son 2N: (BM  B'M) = {000, 001, 010, 011, 100, 101, 110, 111} Sea el código canal C=BM=B2={a1,a2}={000,011}. Es claro que dC=2 Pero C no es maximal, pues existe otro código C'={000, 011, 101, 110}, con dC'=2 también y que tiene más palabras código. Considerando C, nótese que dada la palabra b=101, d(b,a1)=d(b,a2)=2. Así pues, para b no hay (por lo menos) una palabra código tal que d(ai,b)dC-1. Es decir, existe b tal que para todas las palabras código ai se cumple que d(ai,b)>dC-1. El código canal C de longitud N es maximal si y sólo si b ai d(ai,b)  dC-1 Demostración: =>) Si el código canal C de longitud N es maximal entonces b ai d(ai,b)  dC-1. En efecto, supongamos que b ai d(ai,b) > dC-1. Entonces, como b no es una palabra código de C (porque en ese caso ai d(ai,b)=0), podemos construir C' = C  {b} que tiene más palabras código, con la misma mínima distancia dC. Así C no sería maximal. Contradicción que prueba el enunciado. <=) Si b ai d(ai,b)  dC-1 entonces el código canal C de longitud N es maximal. En efecto, supongamos que C no es maximal. Entonces existe otro código C' de longitud N con más palabras código. Por ejemplo, C' = C  {b} con dC'=dC. Siguiendo con el supuesto y sus consecuencias: no hay ninguna palabra ai en C tal que d(ai,b)dC-1, es decir tal que d(ai,b)dC-1 (es lo mismo ai d(ai,b)dC). Que también se puede anotar como b ai d(ai,b)>dC-1. Que es exactamente la negación del supuesto del enunciado y lo contradice. Tal contradicción muestra que C es maximal. Recordemos que los mensajes posibles tienen longitud k, a los que se añaden símbolos de redundancia hasta lograr palabras código de longitud N. De las secuencias posibles de salida bj, sólo M de ellas corresponden a mensajes (codificados). Asumiremos que dichas M palabras código (posibles de enviar) son equiprobables. Como sabemos la velocidad del código se define así: R=Hr(S)/N. Bajo el supuesto de equiprobabilidad la entropía queda como Hr(S) = logrM. De manera que para enviar logrM r-its de información utilizamos una secuencia de N símbolos, es decir, R = (logrM / N). Es claro que R es mayor cuanto mayor es M. En particular, los códigos maximales alcanzan la máxima velocidad posible (para la misma distancia mínima).

120

Por otro lado -en el caso binario-, de las 2N secuencias posibles de salida bj, sólo M=2k corresponden a palabras código enviadas. Tales salidas se asocian a una palabra código a través de una regla de decisión cuya probabilidad de error es: s

s

j1

j1

PE = 1 -  p(a*/bj)·p(bj) = (por Bayes) = 1 -  p(bj/a*)·p(a*) Misma que se minimiza haciendo máxima la sumatoria. Pero precisamente ese es el principio del mínimo error: Se elige el a*{a1,...,ar} tal que ai p(bj/a*)·p(a*)  p(bj/ai)·p(ai) Bajo el supuesto de la equiprobabilidad de las M=2k secuencias el principio del mínimo error es igual al principio de maxima posibilidad que es igual al principio de mínima distancia. Es obvio que un código con muy pocas palabras código puede construirse eligiéndolas muy distantes entre sí (garantizando una baja probabilidad de error). Además H2(S)=log22k=k bits y R=k/N. De manera que para una mayor velocidad es preciso incluir muy pocos bits de redundancia ("incrementando" el valor de k). La clave está pues en incrementar el valor de R (haciendo el código maximal, con todas las palabras código posibles e introduciendo pocos bits de redundancia). Pero también debe tomarse en cuenta la capacidad C del canal (de manera que R
121

Límite de Gilbert-Varshamov.Si el código canal C de longitud N es maximal y tiene distancia mínima dC Entonces el número M de palabras código de C debe ser tal que M  2N / V(N,dC-1). Demostración: 1) Sabemos que si C es maximal, para todas las palabras b de longitud N, hay por lo menos una palabra código a* tal que d(b,a*)dC-1 2) Como C es maximal, se sabe que cada palabra de longitud N dista dC-1 (o menos) de por lo menos una palabra código. ¿Cuántas palabras de longitud N que disten dC-1 (o menos) de la palabra código a* hay? Ya se sabe que hay V(N,dC-1). Consideremos ahora todas las palabras código ai. El número de palabras de longitud N, cuya distancia a cualquiera de las M=2k palabras código ai sea menor o igual que dC-1 es: M·V(N,dC-1). 3) Sólo hay 2N palabras posibles de longitud N. Supongamos que M·V(N,dC-1) < 2N. La única forma de que ello suceda es que hayan palabras de longitud N que no se incluyan en la cuenta M·V(N,dC-1). Es decir, que existan palabras de longitud N, por ejemplo b, tales que d(b,ai) > dC-1. Lo que contradice 1). Así pues el supuesto es erróneo. Luego, M  2N / V(N,dC-1) Que es precisamente lo que queríamos probar Cuando C corrige t errores, sabemos que dC > 2t, es decir, dC  2t+1, que puede escribirse como dC-1  2t. Luego es lícito reescribir el enunciado así: Si el código canal C de longitud N es maximal y corrige t errores Entonces el número M de palabras código de C debe ser tal que M  2N / V(N,2t). Como M=2k, podemos reescribir M·V(N,2t)  2N así: 2k·V(N,2t)  2N Y aplicando logaritmos: k + log2[V(N,2t)]  N Es decir: log2[V(N,2t)]  N-k Es decir, log2[V(N,2t)]  r Es decir, r  log2[V(N,2t)]. Así, los r=N-k bits de redundancia que deben añadirse son, a lo más: log2[V(N,2t)]. Si nos fijamos el enunciado del límite de Gilbert-Varshamov, es claro que esta es una condición necesaria (para la existencia y construcción de un código C que corrija t errores), no suficiente. Juntando ambos límites (y sabiendo que son condiciones necesarias): Si tenemos entradas a'i de longitud k y queremos corregir t bits. Añadiendo r bits de redundancia, que satisfagan: log2[V(N,t)]  r  log2[V(N,2t)] Es posible que exista un código C que efectúe tal corrección. Con esto como ayuda, podemos jugar con N>k. Ejemplo (del libro de Togneri): Se desea construir un código canal C para pre-entradas a'i de longitud k=2. Además se desea que C sea capaz de corregir hasta t=1 errores. ¿ Cúantos r bits de redundancia será necesario añadir ? Es claro que: r=N-k=N-2, t=1, 2t=2.

122

La siguiente tabla nos permite responder en base a los límites log2[V(N,t)]  r  log2[V(N,2t)].

N 3 4 5 6 7

log2[V(N,1)] 2 2.32192809 2.5849625 2.80735492 3

r 1 2 3 4 5

log2[V(N,2)] 2.80735492 3.45943162 4 4.45943162 4.857981

Lo que muestra que es necesario añadir entre 3 y 4 bits de redundancia, para intentar construir un código C que corrija un error (es posible que exista, como que no). Hemos indicado cuántos bits puede detectar o corregir un código canal C. También hemos indicado cuántos bits de redundancia es necesario añadir, para empezar la búsqueda (construcción) de un código canal C con esas características. Esta no es una tarea fácil. A manera de ejemplo presentaremos algunos códigos que pueden hacerlo y sus modos de construcción.

123

ALGUNOS EJEMPLOS DE CÓDIGOS CANAL Debe recordarse en todo momento que es posible suponer un BSC de base (con probabilidad de acierto p y probabilidad de error q). Sobre el cual se piensa transmitir -a través del agrupamiento- secuencias de k símbolos (estas son las 2k pre-entradas a'i). A las que se añaden r bits de redundancia para construir las entradas ai al canal y que constituyen las 2k palabras código del código canal de longitud N (de entre todas las posibles 2N palabras). También debe recordarse que la distancia mínima del código canal C permite colegir cuántos errores puede detectar y/o corregir. Finalmente, aunque el código canal C está pensado a eludir el ruido, es claro que -dependiendo de q y de lo azaroso del ruido- aún es posible que cometamos errores, es decir, existe una probabilidad PE de decodificación errónea. Ello es fácil de imaginar cuando el ruido actúa de tal manera que invierte los bits de la entrada de modo que los convierte en otra palabra código lícita pero diferente de la enviada, en este caso el receptor -utilizando el principio de decodificación de mínima distancia de Hamming que es equivalente al de máxima posibilidad- no lo advierte . Códigos de Paridad.Códigos de paridad impar: Que es cuando se añade un bit de redundancia (de valor 0 o 1) de manera que el número de unos de cada palabra código sea impar. Ejemplo: Pre-entradas con k=2: 00,01,10,11 Código de paridad impar con r=1 bit de redundancia: C={001,010,100,111} Hemos subrayado el bit de redundancia añadido según el esquema. Códigos de paridad par: Que es cuando se añade un bit de redundancia (de valor 0 o 1) de manera que el número de unos de cada palabra código sea par. Ejemplo: Pre-entradas con k=2: 00,01,10,11 Código de paridad par con r=1 bit de redundancia: C={000,011,101,110} Hemos subrayado el bit de redundancia añadido según el esquema. Note que dC=2. Los códigos de paridad par (otro tanto sucede con los de paridad impar) sólo pueden detectar un error y no corrigen ninguno. Ello se desprende del siguiente resultado. Los códigos de paridad par tienen distancia mínima dC=2 Demostración: 1) Sea C un código de paridad par, entonces dC>1. En efecto, supongamos -por reducción al absurdo- que dC1. La única forma de que dC=0 es que C sea Singular lo que no consideraremos (tampoco consideraremos una sóla palabra código). De manera que suponer que dC1 es suponer que hay dos palabras código aiC y ajC tales que d(ai,aj)=1. Es decir, ai y aj difieren en una posición. Ello implica -siendo m el número de unos de ai-, que el número de unos de aj es m+1 ó m-1. Si m es impar, entonces el número de unos de ai es impar, lo que -por el esquema de los códigos de paridad par- nos lleva a que aiC. Lo que contradice aiC. Si m es par, entonces m+1 (ó m-1) es impar, es decir, el número de unos de aj no va con el esquema y ajC. Lo que contradice ajC. Estas contradicciones prueban el enunciado.

124

2) Sea C un código de paridad par, entonces existen dos palabras código ai y aj tales que d(ai,aj)=2. En efecto. Ya indicamos que las pre-entradas son todas las 2k secuencias de longitud k. Así pues, estas pre-entradas se suponen distintas, es decir, d(a'i,a'j)>0. Más aún, existen dos pre-entradas a'i,a'j (por ejemplo dos que son consecutivas, si las pensamos en orden lexicográfico) tales que d(a'i,a'j)=1, es decir, que difieren en un sólo símbolo. Si el número de unos de a'i es m entonces el número de unos de a'j es m+1 ó m-1. Cuando m es par, entonces -por el esquema de paridad par- ai=a'i0 y aj=a'j1. Cuando m es impar, entonces -por el mismo esquema- ai=a'i1 y aj=a'j0. En cualquier caso se cumple que d(ai,aj)=d(a'i,a'j)+d(0,1)=1+1=2. Lo que prueba el enunciado. Los incisos 1) y 2) demuestran lo que deseábamos. En la página 116 se demuestra que un código canal con distancia mínima dC puede detectar dC-1 errores (en el caso de códigos de paridad: 1) y corregir (dC-1)/2 errores (en el caso de códigos de paridad: 0.5, es decir, ninguno). Códigos de Hamming (primera presentación para k=4).- Sea k=4, es decir, las 2k preentradas son 0000, 0001, 0010, etc. Para construir un código canal de Hamming con pre-entradas de longitud k se añaden r bits de redundancia tal que: 2r  k + r +1. En nuestro caso 2r  4 + r +1, es decir, 2r  5 + r. r 2r  5 + r 1 26 2 47 3 88 Luego, añadiremos r=3 bits de redundancia. La exigencia 2r  k + r +1, no es sino el límite de Hamming ya visto, con la intención de obtener un código que corrija t=1 error. En efecto, recordemos que dicho límite es: log2[V(N,t)]  r -que aplicando la inversa del logaritmos se convierte en-: V(N,t)  2r -que con t=1 se convierte en-: r V(N,1)  2 -que expandiendo V(N,1) se convierte en-: 1  N -que expandiendo la sumatoria se convierte en-:   i   2r i 0   N + 1  2r -que con N=k+r se convierte en-: r k+r+12 -que dando la vuelta se convierte en-: 2r  k + r +1 -que es la condición presentada-.

125

Los r bits de redundancia no van necesariamente al final de las pre-entradas, sino como bits de comprobación de paridad que ocupan las posiciones que son potencias exactas de 2 (1, 2, 4, etcétera). Una presentación muy popular para nuestro ejemplo es así: Sean

a'1 a'2 a'3 a'4 p4 p3 p2 p1

los 4 bits de las pre-entradas. Los renombraremos así:

Denotaremos los r=3 bits de paridad así: c3c2c1 mismos que ocupan las posiciones 1, 2 y 4. Así, las entradas al canal, de longitud N = k+r = 4+3 = 7, las podemos representar así: siete bits de una entrada al canal: a7 a6 a5 a4 a3 a2 a1 correspondientes a: p4 p3 p2 c3 p1 c2 c1 Para asignar valores a c3, c2 y c1 se apela a una tabla así: números del 1 al 7 números del 1 al 7 en decimal en binario corresponden a c3 c2 c1 1 0 0 1 2 0 1 0 3 0 1 1 4 1 0 0 5 1 0 1 6 1 1 0 7 1 1 1 Fíjese las columnas que corresponden a c3, c2 y c1 (en particular las posiciones con 1). De ahí obtenemos: c1 debe tomar en cuenta los bits a7 a5 a3 a1 c2 debe tomar en cuenta los bits a7 a6 a3 a2 c3 debe tomar en cuenta los bits a7 a6 a5 a4 Obviamente a1 y c1 (a2 y c2; a4 y c3) son el mismo bit. Luego, la construcción del código (a través de la paridad par y considerando que dicha paridad puede operacionalizarse con la operación XOR -denotada por  -) es bajo el siguiente esquema: c3 = a7  a6  a5 c2 = a7  a6  a3 c1 = a7  a5  a3 Por ejemplo, para la pre-entrada: p4 p3 p2 p1 = 0110 c3 = a7  a6  a5 = 0  1  1 = 0 c2 = a7  a6  a3 = 0  1  0 = 1 c1 = a7  a5  a3 = 0  1  0 = 1 Luego, como c3 c2 c1 = 011, la palabra código correspondiente es: 0110011 Con estas consideraciones, el código de Hamming para nuestro ejemplo es:

126

pre-entradas

0000 0001 0010 0011 0100 0101 0110 0111

código de Hamming C 0000000 0000111 0011001 0011110 0101010 0101101 0110011 0110100

pre-entradas

1000 1001 1010 1011 1100 1101 1110 1111

código de Hamming C 1001011 1001100 1010010 1010101 1100001 1100110 1111000 1111111

Cuya distancia mínima es dC=3. Así, para enviar el mensaje 0110 enviamos su palabra código asociada 0110011. En la decodificación, con la salida b7b6b5b4b3b2b1 se calcula la secuencia c3c2c1 así: c3 = b7  b6  b5  b4 c2 = b7  b6  b3  b2 c1 = b7  b5  b3  b1 Si c3c2c1 = 000, entonces la salida no tiene errores. En otro caso, la secuencia c3c2c1 denota -en binario- la posición del bit errado. Ejemplo: Sea la salida b7b6b5b4b3b2b1=0110010 c3 = b7  b6  b5  b4 = 0  1  1  0 = 0 c2 = b7  b6  b3  b2 = 0  1  0  1 = 0 c1 = b7  b5  b3  b1 = 0  1  0  0 = 1 La secuencia c3c2c1=001, por tanto denota que hay un error en el bit b1. Luego, la palabra corregida es 0110011, de la cual extraemos las posiciones p4p3p2p1 que no son bits de paridad, según el esquema: siete bits de una salida del canal: b7 b6 b5 b4 b3 b2 b1 correspondientes a: p4 p3 p2 c3 p1 c2 c1 Luego, el mensaje enviado es: 0110. En el siguiente capítulo incluiremos una segunda presentación -más genérica- de los códigos de Hamming, así como sus propiedades. Códigos de Hadamard.- Empecemos definiendo las matrices de Hadamard. Una matriz HN x N se llama matriz de Hadamard de orden N cuando: a) Sus elementos son H(i,j) = 1 o H(i,j) = -1 b) Sus (distintas) filas son ortogonales, es decir, ij riºrj = 0 [ri y rj son filas de H] (la ortogonalidad se define y amplía en el Anexo 3) Ejemplo: 1 1  H=  H(1,1) = H(1,2) = H(2,1) = 1  H(2,2) = -1 1 1 r1 = [1 1] r2 = [1 -1] r1 º r2 = [1 1]º[1 -1] = (1 · 1) + (1 · -1) = (1) + (-1) = 0 Luego H, es una matriz de Hadamard de orden N=2.

127

A partir de una matriz de Hadamard de orden N se construye un código binario -llamado código de Hadamard- con 2N palabras código (de longitud N) así: i) Cambiamos los valores -1 por 0. ii) Cada fila wi es una palabra código. iii) Invertimos los bits de wi para obtener una nueva palabra código, wi = wi. Ejemplo: Para la matriz H de orden n=2 de arriba. 1 1 i)   1 0 ii) {11, 10} iii) {00, 01} Finalmente obtenemos el código: C = {11, 10, 00, 01} Un código C de Hadamard tiene distancia mínima dC=N/2 Demostración: 1) Compararemos dos palabras código que resulten del paso iii, es decir, de la inversión de bits. Consideremos la fila i de la matriz. A partir de los incisos i) y ii) es obvio que i d(wi, wi )=N. 2) Ahora compararemos dos palabras código diferentes (que no resulten del paso iii, es decir, que no resulten de la inversión de bits). Sabemos que, en la matriz H de orden N, ij ri º rj = ri1·rj1 + ... + riN·rjN = 0. Como cada sumando (o cada producto) es 1 o -1, para que el resultado final sea cero, deben haber la mitad de sumandos igual a 1 y la otra mitad igual a -1. Es decir, N debe ser par. Para que N/2 de los sumandos (o de los productos) sean iguales a -1, estos sumandos (o productos) deben ser tales que sus dos componentes deben ser diferentes. [Por ejemplo para que rik·rjk = -1, o bien rik = 1 y rjk = -1 o bien rik = -1 y rjk = 1, es decir, rik y rjk deben ser diferentes]. Eso, en términos de la distancia de Hamming no es otra cosa que ij d(wi,wj)=N/2. Lo mismo sucede si comparamos dos palabras código diferentes que resulten de la inversión, o una palabra código no invertida con otra no invertida pero que provengan de filas diferentes. Ello prueba el enunciado.

Una forma de construir matrices de Hadamard de órdenes superiores es siguiendo el siguiente resultado. H H  Si H es una matriz de Hadamard de orden N y H' =   H  H  Entonces H' es una matriz de Hadamard de orden 2N Demostración: Se supone por hipótesis que las filas de H son ortogonales y que sus elementos son 1 o -1.

128

a) Luego, los elementos de H' también son 1 o -1, pues H' se construye a partir H. b) Sean ri=[ri1 ... riN] y rj=[rj1 ... rjN] dos filas diferentes de H. Por ser H ortogonal, tenemos que: riºrj = ri1·rj1 + ... + riN·rjN = 0. Sean r'i y r'j dos filas diferentes de H'. Luego, b1) r'i º r'j = r'i1·r'j1 + ... + r'iN·r'jN + r'i(N+1)·r'j(N+1) + ... + r'i(2N)·r'j(2N) = ri1·rj1 + ... + riN·rjN + ri1·rj1 + ... + riN·rjN = riºrj + riºrj = 0 + 0 = 0 Cuando r'i y r'j son dos filas de la parte superior del esquema. b2) r'i º r'j = r'i1·r'j1 + ... + r'iN·r'jN + [ r'i(N+1)·r'j(N+1) + ... + r'i(2N)·r'j(2N)] = ri1·rj1 + ... + riN·rjN - [ ri1·rj1 + ... + riN·rjN ] = riºrj - [ riºrj] = 0 - [0] = 0 Cuando r'i y r'j son dos filas de la parte inferior del esquema. b3) r'i º r'j = r'i1·r'j1 + ... + r'iN·r'jN + [ r'i(N+1)·r'j(N+1) + ... + r'i(2N)·r'j(2N)] = ri1·rj1 + ... + riN·rjN + [ ri1 · -rj1 + ... + riN · -rjN ] = riºrj + [0] = 0 + [0] = 0 Cuando r'i es una fila de la parte superior del esquema y r'j de la parte inferior. La parte entre braquetas [] es igual a cero pues, en riºrj = ri1·rj1 + ... + riN·rjN = 0, ya vimos que la mitad de sus sumandos es igual a 1 y la otra mitad igual a –1, por ello la introducción del signo negativo [ri1 · -rj1 + ... + riN · -rjN]= [-(ri1·rj1) + ... + (riN·rjN)] sigue conservando el hecho de que la mitad de sus sumandos sea igual a -1 y la otra mitad igual a 1.

Nótese que en los códigos de Hadamard se considera la longitud N del código C (que es el orden de la matriz H), sin entrar en consideraciones sobre la longitud k de las pre-entradas, ni sobre el número de bits de redundancia. Los límites de Hamming y de Gilbert-Varshamov pueden hacer usual este tratamiento: es decir, construir códigos canal considerando básicamente la longitud N (encapsulando los valores de k y r). Más aún los códigos de Hamming y de Hadamard son ejemplos de lo que se denomina códigos lineales, materia del siguiente capítulo.

129

CÓDIGOS LINEALES En otro capítulo hemos hablado de la estandarización de las entradas a un canal: considerando palabras código de longitud fija y la construcción de un código canal (bloque) para ellas. Como hacíamos entonces, prescindiremos de la conexión con una Fuente-S y nos centraremos en el estudio de los códigos canal, en particular de una clase de ellos llamados códigos lineales. De hecho, hemos flexibilizado más nuestro enfoque considerando maneras de construir códigos canal con una longitud de bloque predeterminada (por ejemplo los códigos de Hadamard), sin un código de origen dado. Estamos pues interesados, no sólo en la definición de un código lineal (para ver si un conjunto de palabras código la satisface), sino en establecer sus propiedades y describir formas de construir códigos lineales con ciertas características. En el Anexo 3 se describe la definición de un espacio lineal junto a algunos tópicos de teoría de números y álgebra lineal que deben tenerse en mente (su lectura previa es obligatoria y se considera un recordatorio de material que ya se conoce). Si para el espacio lineal (V, F,  , +, ×, •) nos tomamos las licencias de notación siguientes (como es común hacer): Escribir V = 2N no como vectores sino como secuencias de símbolos en { 0, 1 } , es decir, sin comas y sin paréntesis. Utilizar el mismo símbolo '+' para las operaciones + y  . Omitir los símbolos × y • , o bien utilizar para ellos el mismo símbolo ·. Hecho esto, podemos decir de manera libre que estamos trabajando con el espacio lineal 2N = { w1, …, wm } wi es una secuencia de N símbolos; m=2N w1=0…0; etc. Es decir, cuando los vectores se asocian a palabras código (secuencias de N símbolos), la operación + para palabras código es la suma elemento a elemento (y esta es la suma boolena o la suma módulo 2), la operación × es la multiplicación boolena o la multiplicación módulo 2, la multiplicación escalar es 1•w=w o bien 0•w=0…0, y omitimos los símbolos × y • (o utilizamos para ellos el mismo símbolo ·); resulta que 2N no es otra cosa que un espacio lineal (de palabras código de longitud N). Código lineal.- Un código lineal C es un subespacio lineal de 2N. Es decir, bajo las misma licencias de notación, C  2N es un código lineal cuando (w + u)  C para u,w  C (b·u)  S para u  S y b  F Nótese que la condición (b·u)  S se simplifica a w=0…0  C, es decir, a que la palabra código correspondiente a una secuencia de (N) ceros esté en C. Pero esta condición está subsumida en la primera. En efecto, tomando w=u la condición es (u + u)  C, y como (u + u)=0…0, finalmente la condición en este caso es que w=0…0  C. Luego, las condiciones formales para que C sea un subespacio lineal de 2N, se resumen así: Un código bloque C -de longitud N- se dice lineal si la suma de dos palabras código es otra palabra código. Que puede tomarse también como definición.

130

En adelante utilizaremos el mismo símbolo · para las operaciones ×,• (e incluso para la multiplicación de matrices y la concatenación de cadenas) y lo escribiremos sólo cuando aporte claridad. Ejemplo: En el Anexo 3 vimos que S={ (0,0,0), (1,0,1), (0,1,1), (1,1,0) } es un subespacio lineal del espacio lineal 23. Si hacemos C=S y escribimos C con las licencias mencionadas, tenemos el siguiente código (subespacio) lineal: C = { 000, 101, 011, 110 }. Sin embargo, también podemos determinar si C es lineal o no, verificando que la suma (módulo 2, símbolo a símbolo) de dos palabras código cualesquiera sea otra palabra código. Por ejemplo: 101 + 011 = 110. Ya dijimos que una consecuencia de la definición de subespacio lineal, es que la palabra código correspondiente a una secuencia de (en nuestro ejemplo tres) ceros debe estar en C: podemos empezar la verificación ahí. Dado que un código lineal C –bloque, de longitud N- es un subespacio lineal de 2N (en adelante daremos esto por sentado y ya no lo escribiremos), podemos considerar la base de dicho subespacio lineal así como su dimensión. Colocando los elementos de una base como filas de una matriz, obtenemos lo que se denomina la matriz generadora G del código C. Si el código C es de dimensión k, su matriz generadora G será una matriz de (k×N):  u1  Gk × N =  ...  donde una base de C es B={u1, …, uk}.  uk  Ejemplo: En el Anexo 3 se muestra que C = { 000, 101, 011, 110 } tiene como base B = {101, 011}, luego la matriz generadora G2×3 de C es: 1 0 1 G=   0 1 1 C es un código lineal de dimensión 2. Sea B={u1, …, uk} la base de un subespacio lineal C. Se sabe que gen(B)=C. Es decir, la base de un subespacio lineal, lo genera. En otros términos, cada palabra código w de un código lineal C es una combinación lineal de los k elementos que están en una base de C: w = a1∙u1 + … + ak∙uk = [a1 … ak]·G donde ai  {0,1} De este modo se puede especificar un código lineal C de longitud N presentando su matriz generadora G.

Ejemplo:

1 0 1 El código C de arriba puede especificarse a través de su matriz generadora: G =   0 1 1 En efecto, el código completo se obtiene como se indicó, w=[a1 … ak]·G:

131

1 [0 0]·  0 1 [1 0]·  0

0 1 = [0 0 0] 1 1 0 1 = [1 0 1] 1 1

1 [0 1]·  0 1 [1 1]·  0

0 1 = [0 1 1] 1 1 0 1 = [1 1 0] 1 1

Es decir, C = { 000, 101, 011, 110 } Considerando el código (canal) C de longitud N, nótese que cuando su dimensión es k, para obtener las palabras código de C a través de G, utilizamos todas las palabras de longitud k (a1…ak); podemos ver a estas palabras como el resultado de la codificación de una fuente de información, es decir, lo que hemos llamado el código de origen –que es bloque de longitud k, al que se añaden r = N- k bits de redundancia(Visto así, el código lineal C de longitud N es el resultado de codificar –una vez más y añadiendo bits de redundancia- las palabras código a1…ak del código de origen de longitud k; es claro, que no siempre todas estas cadenas a1…ak son palabras código del código de origen, pero eso no dificulta la construcción de C pues siempre es posible ignorarlas). Peso de una palabra código.- El peso de una palabra código w de longitud N se define así: peso(w) = d(w,0…0) [En términos de la distancia de Hamming; 0…0 representa una secuencia de N ceros]. Nótese que el peso(w) no es otra cosa que el número de posiciones diferentes de 0, en un código binario eso no es otra cosa que el número de unos. Recuerde que estamos considerando códigos binarios bloque (de longitud N); asumimos también que son No Singulares (C  2N), y de ahí que son instantáneos (y unívocamente decodificables).

Distancia mínima de un código lineal.Si C es un código lineal Entonces dC = min{ peso(w) / w  C, w≠0…0} 0…0 representa una secuencia de N ceros. Demostración: Es claro que d(u,v) = peso(u+v) = peso(w) donde w=u+v (1) Luego, dC = min{ d(u,v) / u,v  C; u≠v} por definición = min{ peso(u+v) / u,v  C; u≠v } por (1) = min{ peso(w) / w=u+v; u,v  C; u≠v } por (1) = min{ peso(w) / w  C, w≠0…0} Pues como C es no singular y u≠v, resulta que (u+v=)w será diferente de 0…0. Además como u,v  C, es decir, tomamos todos los distintos pares de palabras código, su suma u+v abarca todas las palabras código w de C. Ello es evidente tomando v=0…0 (ya vimos que si C es lineal, la secuencia de ceros debe estar en el código). Si colocamos las palabras código de C como filas de una matriz, en el Anexo 3 se muestra que la determinación de la matriz generadora G (la base) del código C puede hacerse hallando la forma escalonada de C, mediante operaciones elementales sobre filas (por ejemplo con el conocido método de Gauss) y recogiendo sólo las filas diferentes de cero.

132

Ejemplo: Para el código C1 = { 0000, 0001, 0100, 0101 } obtenemos su matriz generadora así: 0 0 0 0  0 1 0 1  0 0 0 1  0 0 0 1     sumando la fila 1 a la 2: C1 = permutando las filas 1 y 4 :  0 1 0 0  0 1 0 0      0 1 0 1  0 0 0 0  0 1 0 1  0 1 0 1  0 1 0 0      sumando la fila 2 a la 3 : 0 1 0 0 0 1 0 0  0 0 0 0      0 0 0 0  0 0 0 0 

0 1 0 1  Luego, G1 =   0 1 0 0  Aprovechemos este ejemplo para recordar que dada una matriz generadora Gk × N se obtienen todas las palabras código multiplicando v·G, donde v=[a1 … ak]. Así: 0 0 0 1  Para G2 =   su código asociado es C2 = { 0000, 0100, 0001, 0101 }. 0 1 0 0 

1 0 0 0 Para G3 =   su código asociado es C3 = { 0000, 0100, 1000, 1100 }. 0 1 0 0  Nótese que los tres códigos tienen la misma distancia mínima. Nótese que, salvo el orden de escritura de las palabras código, C1 y C2 son iguales y que G2 se obtiene de G1 mediante operaciones elementales sobre filas (fila 1 = fila 1 + fila 2). Nótese que G3 se obtiene de G2 mediante permutación de columnas (la 1 y la 4) y que las palabras código de C3 son las palabras código de C2 con los símbolos primero y cuarto permutados. Esto nos lleva a preguntarnos cuándo dos matrices generadoras G y G‟ generan el mismo código o cuál la relación entre sus códigos generados. Repetimos: En el Anexo 3 se ve que efectuar cambios en una matriz generadora G, a través de operaciones elementales sobre filas, devuelve una matriz equivalente G‟, donde el espacio de las filas de G es el mismo que el espacio de las filas de G‟, es decir, RG=RG‟. Es decir, las matrices G y G‟ generan el mismo código. Esto permite obtener otras matrices generadoras para el mismo código a partir de una dada. Además como la dimensión de un (sub)espacio lineal es única, todas estas matrices tendrán igual número de filas diferentes de cero (linealmente independientes). Sea G la matriz generadora del código C. Sea la matriz G‟ que se obtiene de G permutando dos columnas. Sea C‟ el código generado por G‟. Diremos que C‟ es un código equivalente a C.

133

En el Anexo 3 vimos que los espacios lineales C‟ y C difieren sólo en el orden de sus símbolos. Así pues C‟ es equivalente a C en el sentido que las palabras código de C‟ son el resultado de permutar los símbolos de las palabras código de C en exactamente las mismas posiciones. Es obvio que C‟ y C tienen la misma distancia mínima. Por ejemplo los códigos C2 y C3 de antes son equivalentes. Así pues, la permutación de columnas preserva todas las propiedades importantes para la corrección y detección de errores entre los códigos generados por la matriz original y la matriz resultante (en particular la distancia mínima), por ello consideraremos a dichos códigos esencialmente los mismos.

 1 0 0 0 Retomemos la matriz generadora G3 =   , donde hemos puesto en negrita la 0 1 0 0 parte más a la izquierda. Forma canónica de G.- La matriz generadora Gk × N de un código lineal C de dimensión k está en forma canónica (o sistemática) si es de la forma: Gk × N = [ Ik × k : Ak × N-k ] Ik × k es la matriz identidad; Ak × N-k es una matriz arbitraria Diremos que un código lineal C es sistemático (o está en forma canónica) si su matriz generadora G está en forma canónica. Se denomina así porque al construir las palabras código w=[a1 … ak]·G, como G tiene una matriz identidad en su parte izquierda, resulta que w=a1…akp1…pr (con r = N-k). Es decir, el mensaje original a1…ak aparece íntegro a la izquierda y los símbolos p1…pr son dígitos de testeo (bits de paridad) y se calculan así: [p1 … pr] = [a1 … ak]·A. Dado el código lineal C podemos obtener una matriz generadora G1 escalonando C. Dada la matriz G1 podemos obtener la matriz generadora G en forma canónica aplicando a G1 operaciones elementales sobre filas y/o columnas. Código dual.- Sea C un código lineal. Denotaremos por C┴ y llamaremos código dual de C al código definido como sigue: C┴ = { v  2N / wºv=0, w  C } Es decir, en C┴ están todas las palabras ortogonales a las palabras código de C. Sea Gk × N la matriz generadora de C. Sabemos que el núcleo de G es el conjunto: NG = { v  2N / G·vT = 0 } donde 0 representa una columna de k ceros En el Anexo 3 se señala que NG es un subespacio lineal de 2N con dimensión N-k. Más aún, probaremos que C┴=NG: Sea C un código lineal con matriz generadora G. i) Si v  C┴ Entonces v  NG Demostración: Por definición de C┴ y NG un enunciado equivalente es: Si w  C wºv=0 Entonces G·vT = 0 Supongamos que G·vT  0 Sean u1, …,uk las filas de G (es decir, los elementos de una base de C). Es evidente que G·vT = [u1ºv ... ukºv]T

134

Luego estamos suponiendo que [u1ºv ... ukºv]T  [0 ... 0] T Es decir, i 1 i k uiºv  0 (*) Por otro lado, es inmediato que ui  C, es decir, los elementos de la base están en C. Luego, por hipótesis, i 1 i k uiºv=0 (**) La contradicción entre (*) y (**) muestra que nuestro supuesto es erróneo y prueba el enunciado. ii) Si v  NG Entonces v  C┴ Demostración: Por definición de C┴ y NG un enunciado equivalente es: Si G·vT = 0 Entonces w  C wºv=0 De manera semejante al anterior inciso, podemos reescribir G·vT = 0 así: [u1ºv ... ukºv]T = [0 ... 0] T Es decir, i 1 i k uiºv=0 (***) Por otro lado, sea w  C, es decir, w=a1∙u1  …  ak∙uk (combinación lineal de la base) Veamos qué sucede con wºv: wºv = (a1∙u1  …  ak∙uk)ºv obvio = a1∙(u1ºv) +…+ ak∙(ukºv) probado en el Anexo 3 = a1∙0 +…+ ak∙0 por (***) =0 obvio Es decir, wºv=0. Que es lo que se quería probar. Así pues C┴ es un subespacio lineal, concretamente es el núcleo de G. Además, una base cualquiera de C┴ tiene N-k elementos. Sea H = {h1, ... ,hN-k} una base de C┴. Podemos colocar los elementos de la base H como filas de una matriz llamada matriz generadora de C┴. Matriz de (testeo de) paridad.- Sea C un código lineal con matriz generadora Gk × N. Se denomina matriz de (testeo de) paridad de C, a: H(N- k) × N la matriz generadora de C┴. Es claro que las palabras código v=v1v2...vN de C┴ se obtienen así: v = b1∙h1 + … + bN-k∙hN-k donde bi  {0,1} = [b1 … bN-k]·H Es evidente que los elementos de la base G (las filas de G) están en C; igual que los elementos de la base H (las filas de H) están en C┴. Como por definición de C┴ (y por conmutatividad del producto interno), los elementos de C y C┴ son ortogonales entre sí. Resulta que: G·HT = 0k × (N- k) H·GT = 0(N-k) × k

donde 0k × (N- k) representa una matriz de ceros. donde 0(N-k) × k) representa una matriz de ceros.

Por este motivo, así como H es la matriz de testeo de paridad de G, también G es la matriz de testeo de paridad de H.

135

Obtención de la matriz de paridad H.- En la página 134 vimos que G·xT = 0 si y sólo si w  C wºx=0. Es decir, NG (C┴) es el conjunto de todas las soluciones del sistema G·xT = 0k × 1: g11 ... g1N   ... ... ...  · [x ... x ]T = [0 ... 0]T 1 N   gk 1 ... gk N  Reescribiendo: g11.x1 + g12.x2 + … + g1N.xN = 0 g21.x1 + g22.x2 + … + g2N.xN = 0 … gk1.x1 + gk2.x2 + … + gkN.xN = 0 En el Anexo 3 se señala que k + dim(NG) = N, luego N > k. Dado que hay más incógnitas que ecuaciones se garantiza la existencia de soluciones no triviales. Luego podemos simplemente tomar N-k linealmente independientes de entre ellas y así obtenemos una base de C┴. Ejemplo: 1 0 1 Sea G =   la matriz generadora de C={ 000, 101, 011, 110 } 0 1 1 El sistema G·xT = 0k × 1 una vez efectuada la multiplicación de matrices es: 1.x1 + 0.x2 + 1.x3 = 0 es decir x1 + x3 = 0 es decir x1 = -x3 0.x1 + 1.x2 + 1.x3 = 0 x2 + x3 = 0 x2 = -x3 Como en el campo binario el inverso de 0 es 0 y el inverso de 1 es 1. Es decir, el inverso de xi es xi. Resulta que las soluciones al sistema G·x = 0 son: x1 = x3 x2 = x3 x3 = x3 (= t) Luego NG = C┴ = gen(x3·[ 1 1 1 ]). Es decir, C┴ = { 000, 111 } La base buscada es H = [ 1 1 1 ].

Ya vimos que, dado el código lineal C, siempre es posible obtener G en forma canónica. El siguiente resultado permite obtener H de manera inmediata. Si Gk × N = [ Ik × k : Ak × N-k ] está en forma canónica Entonces su matriz de paridad es H = [AT : I(N- k) × (N- k) ] Demostración: 1) Las filas de la matriz H(N- k) × N son linealmente independientes. 0 a11 ... a1(N - k )  1  u1     ... ... ...  Sea G =  ...  = [ Ik × k : Ak × N-k ] =  ... 0  uk  1 ak 1 ... ak (N - k ) 

136

ak 1 1 0  a11  v1  ... ...  Luego H =  ...  = [ AT : I(N- k) × (N- k) ] =  a1(N - k )  vN - k  ak (N - k ) 0 1 Veamos qué sucede con la ecuación b1∙v1 +…+ bN-k∙vN-k = 01 × N Puede reescribirse como: b1∙[a11 ... ak 1 1 0 ... 0] +…+ bN-k∙[a1(N-k) ... ak (N-k) 0 ... 0 1] = 01 × N Y a su vez –distribuyendo bi y realizando la suma vectorial- como: b1∙a11 +

... + bN-k∙a1(N-k) = 0 ... b1∙ak1 + ... + bN-k∙ak (N-k) = 0 b1∙1 + b2∙0 + ... + bN-k∙0 =0 b1∙0 + b2∙1 + ... + bN-k∙0 =0 ... b1∙0 + … + bN-k-1∙0 + bN-k∙1 =0 Cuya única solución es obviamente la trivial. Es decir; las filas de H son linealmente independientes 2) Las filas de H son ortogonales a las filas de G. Como Gk × N = [ Ik × k : Ak × N-k ] y H = [AT : I(N- k) × (N- k) ], entonces: G·HT = [ Ik × k : Ak × N-k ]·[AT : I(N- k) × (N- k) ]T obvio T T (A ) = [ Ik × k : Ak × N-k ] · I(N- k) × (N- k) operaciones sobre matrices A = [ Ik × k : Ak × N-k ] · operaciones sobre matrices I(N- k) × (N- k) = [ (Ik × k · A) + (Ak × N-k · I(N- k) × (N- k))] = [ A + A] = 0k × (N-k)

operaciones sobre matrices operaciones sobre matrices suma -módulo 2- de matrices

Un razonamiento semejante muestra que H·GT = 0(N-k) × k, es decir, Las filas de G son ortogonales a las filas de H. 3) gen(H) = C┴. 3.1) Toda combinación lineal de (las filas de) H es ortogonal a las filas de G. En efecto, una combinación lineal de H es: [b1 … bN-k]·H donde bi  {0,1} T T Luego: [b1 … bN-k]·H·G = 01 × k pues H·G = 0(N-k) × k 3.2) Si v  gen(H) Entonces v  C┴. En efecto, sea v=[b1 … bN-k]·H = [v1v2...vN] una combinación lineal de H. g11 ... g1N  Sea G =  ... ... ...  gk 1 ... gk N 

137

Ya vimos en 3.1 que v es ortogonal a las filas de G: v1g11 + v2g12 + … + vNg1N = 0 v1g21 + v2g22 + … + vNg2N = 0 (*) … v1gk1 + v2gk2 + … + vNgkN = 0 Sea w  C, es decir, w es una combinación lineal (de las filas) de G: w = [a1…ak]·G = [a1g11 + a2g21 +…+ akgk1 a1g12 + a2g22 +…+ akgk2 … a1g1N + a2g2N +…+ akgkN] (donde hemos añadido negrita sólo para diferenciar los elementos) Veamos qué sucede con el producto interno vºw: vºw = [v1v2...vN] º [a1g11 + a2g21 + … + akgk1 a1g12 + a2g22 + … + akgk2 … a1g1N + a2g2N + … + akgkN] =

v1(a1g11 + a2g21 + … + akgk1) + v2(a1g12 + a2g22 + … + akgk2) … + vN(a1g1N + a2g2N + … + akgkN)

= v1a1g11 + v1a2g21 + … + v1akgk1 + v2a1g12 + v2a2g22 + … + v2akgk2 … + vNa1g1N + vNa2g2N + … + vNakgkN a1(v1g11 + v2g12+…+ vNg1N) + a2(v1g21 + v2g22+…+ vNg2N) … + ak(v1gk1 + v2gk2+…+ vNgkN) =0

conmutando y asociando, es decir, reordenando con respectoa los ai

=

pues por (*) cada paréntesis es cero

Por conmutatividad del producto interno: wºv=0. Como w es cualquier palabra código de C, hemos mostrado que una combinación lineal de H es ortogonal a cualquier palabra código de C. Entonces v  C┴. 3.3) Si v  C┴ Entonces v  gen(H). (Basado en el trabajo del Dr. W. Cherowitzo) Sea v  C┴, donde v = [v1v2...vN]. Sea z = v + (vk+1•r1 + ... + vk+(N-k)•rN-k) (*) ak 1 1 0  r1   a11 ... ...  Sea H =  ...  =  rN - k  a1(N - k ) ak (N - k ) 0 1 Es obvio que ri  gen(H), luego 3.2 nos muestra que ri  C┴.

Como C┴=NG y ya vimos que NG es un subespacio lineal, es obvio que C┴ es un subespacio lineal. Por lo tanto vk+i•ri  C┴. Además la suma de elementos en un subespacio lineal sigue en el subespacio lineal. Luego z  C┴.

138

¿ Cómo son los componentes de z = [z1z2...zN] ? z = [v1v2 ... vk vk+1 ... vN] + (vk+1•r1 + ... + vk+(N-k)•rN-k) = [v1v2 ... vk vk+1 ... vN] + (vk+1•[ a11 ... ak1 1 0 … 0] ... + vN•[a1(N-k) ... ak(N-k) 0 ... 0 1]) = [v1v2 ... vk vk+1 ... vN] + ([vk+1.a11 ... vk+1.ak1 vk+1 0 … 0] ... + [vN.a1(N-k) ... vN.ak(N-k) 0 ... 0 vN]) La negrita es sólo para resaltar. En dicha parte resaltada nótese que desde el componente k+1, hasta el componente N, los valores son: vk+1, ..., vN, respectivamente. Mismos que sumados a la parte no resaltada permiten deducir que: z = [z1z2 ... zk zk+1 ... zN] = [z1z2 ... zk 0 ... 0] Como z  C┴=NG, entonces G·zT = 0k × 1, es decir: 0 a11 ... a1(N - k )  1 T T  ... ... ...  ·[z1z2 ... zk 0 ... 0]T G·z = [ Ik × k : Ak × N-k ]·z =  ... 1 ak 1 ... ak (N - k )  0 = [z1z2 ... zk]T = 0k × 1 Pero entonces, para i de 1a k: zi = 0. Ello implica que z = 0. Luego, por (*): v = vk+1•r1 + ... + vk+(N-k)•rN-k (una combinación lineal de H) Entonces v  gen(H). Como dim(C┴)=N-k; las N-k filas de H son linealmente independientes y ellas generan C┴, entonces H es una base de C┴, es decir, es la matriz de testeo de paridad de G. Ejemplo: 1 0 1 Sea G =   la matriz generadora de C={ 000, 101, 011, 110 } 0 1 1 Como G está en forma canónica, H = [ 1 1 1 ]. Cuando G no está en forma canónica hay un modo de hallar su matriz de paridad H: 1) Obtenga la forma canónica Gc=[ I : A ], a partir de G, efectuando operaciones elementales sobre filas y/o permutaciones de columnas. 2) Obtenga Hc=[ AT : I ] la matriz de paridad de Gc. 3) Obtenga H a partir de Hc, aplicando en orden inverso las permutaciones de columnas efectuadas en el paso 1. Ya vimos que cuando se efectúan únicamente operaciones elementales sobre filas: C = gen(G) = gen(Gc) = Cc. En este caso es obvio que C┴ (el espacio dual de C) es idéntico al espacio dual de gen(Gc), de manera que Hc = H. También vimos que cuando –además- se efectúan permutaciones de columnas (al hallar Gc a partir de G), los códigos resultantes son esencialmente los mismos difiriendo sólo en el orden de sus símbolos. De igual manera Hc y H generan espacios equivalentes en el sentido que son el resultado de permutar los símbolos de sus palabras código en exactamente las mismas posiciones. Ello justifica el paso 3. 139

Ejemplo: 0 0 0 1  Sea G =   Obtenemos Gc mediante permutación de las columnas 1 y 4: 0 1 0 0   1 0 0 0 0 0 1 0  Gc =  Cuya matriz de paridad es Hc =    0 1 0 0 0 0 0 1

0 0 1 0  Permutando en Hc las columnas 4 y 1, obtenemos la matriz de paridad H =  . 1 0 0 0 Síndrome.- Denotaremos por s y llamaremos síndrome de la cadena w  2N a: s = w·HT. H recibe el nombre de matriz de testeo de paridad debido a lo siguiente: Sea C un código lineal con matriz generadora G y matriz de testeo de paridad H. Si w  C Entonces s = 0 Demostración: Cualquier palabra código es una combinación lineal de los elementos de la base G, es decir, w = a1…ak·G, luego s = w·HT = a1…ak·G·HT = a1…ak·(G·HT) = 01 × (N- k) De este modo, desde el punto de vista del receptor, ya tenemos una forma de testear si una palabra w que llega (w  2N) , es o no una palabra código (en C): Calculamos su síndrome y vemos si es 0; si es así w  C, en otro caso no está en C (se detecta uno o varios errores). Esto es más práctico que contrastar w con cada una de los elementos de C (imagine por ejemplo un conjunto C muy grande). Obviamente aún debemos considerar la posibilidad de que la palabra código enviada haya sido objeto de tanto ruido que se transformó en otra palabra código (que aunque lícita está errada respecto del envío original). Cuando no es este el caso, falta averiguar si podemos determinar en qué posiciones ha variado la palabra código enviada hasta convertirse en una secuencia que no corresponde a una palabra código. Los códigos lineales aún nos deparan agradables sorpresas a este respecto. Por todo lo visto hasta ahora, los códigos lineales (de longitud N) suelen venir por pares: - el código C con matriz generadora G y matriz de testeo de paridad H - el código C┴ con matriz generadora H y matriz de testeo de paridad G. Ejemplo:

1 0 1 Antes vimos que, para G =   , C={ 000, 101, 011, 110 } y H = [ 1 1 1 ]. 0 1 1 Por tanto C┴ = { 000, 111 }. 0  Nótese (y es fácil verificarlo) que G·HT =   y que H·GT = [0 0]. 0  1 1 0 0 Sin embargo, es posible que C=C┴ (G=H) , por ejemplo con G =  . 0 0 1 1  140

Código extendido o expandido.- Sea C un código lineal (de longitud N) con matriz generadora G. Denotaremos por Ce y llamaremos código extendido (de C) a: Ce = { v / v = v1v2...vNvN+1 = w1w2...wNvN+1, w = w1w2...wN, w  C, vN+1 = w1+w2+...+wN } Es decir, se añade a w un dígito más de paridad. Es claro que Ce es de longitud N+1 y tiene el mismo número de palabras código que C. Además : Si C es lineal entonces Ce también es lineal. En efecto, sean u,v  Ce, es decir : v = wvN+1 donde w=w1w2...wN  C y vN+1 = w1+w2+...+wN u = xuN+1 donde x=x1x2...xN C y uN+1 = x1+x2+...+xN Luego, z = u+v = (w+x)zN+1 como C es lineal (w+x)  C y zN+1=(w1+x1)+…+(wN+xN) Es decir z  Ce.

 u1 g11 ... g1N  Sea G =  ...  =  ... ... ...   uk  gk 1 ... gk N   r1 g11 ... Entonces Ge = ... =  ... ...  rk  gk 1 ...

la matriz generadora de C

g1N ... gk N

g11...g1N   es la matriz generadora de C . ... e  gk 1...gk N 

Demostración : Probaremos que las filas de Ge son linealmente independientes y que generan Ce. Es obvio que las filas de G son linealmente independientes, es decir: a1•u1 + ... + ak•uk = 01 × N implica que ai ai=0 (*) Veamos qué sucede con la ecuación: b1•r1 + ... + bk•rk = 01 × (N+1) Que puede reescribirse como: b1•[u1 g11+…+ g1N] + ... + bk•[uk gk1+…+ gkN] = 01 × (N+1) Es decir : [b1•u1 b1·(g11+…+ g1N)] + ... + [bk•uk bk·(gk1+…+ gkN)] = 01 × (N+1) Que puede reescribirse como: b1•u1 + ... + bk•uk = 01 × N b1·(g11+…+ g1N) + ... + bk·(gk1+…+ gkN) = 0 Por (*) se concluye que tal sistema sólo acepta la solución trivial. Es decir, las filas de son Ge son linealmente independientes. Nótese que ello indica que C y Ce tienen la misma dimensión. Por otro lado: v  gen(Ge) si y sólo si v = b1•r1 + ... + bk•rk si y sólo si v = b1•[u1 g11+…+ g1N] + ... + bk•[uk gk1+…+ gkN] si y sólo si v = [b1•u1 + ... + bk•uk b1·(g11+…+ g1N) + ... + bk·(gk1+…+ gkN)] si y sólo si v = [w b1·(g11+…+ g1N) + ... + bk·(gk1+…+ gkN)] donde w=[b1•u1 + ... + bk•uk]= [ b1•[g11 … g1N] + ... + bk•[gk1… gkN] ]=w1w2...wN  C vN+1=w1+w2+...+wN si y sólo si v  Ce.

141

Si C es un código lineal binario con distancia mínima dC y Ce es el código expandido de C Entonces dCe = dC+1 o dCe = dC según dC sea impar o par respectivamente. Demostración: Sabemos que en un código lineal dC = min{ peso(w) / w  C, w≠0…0}. Si v=wvN+1  Ce, con w  C y vN+1=w1+w2+...+wN es evidente que: peso(v) = peso(w) cuando peso(w) es par; o bien peso(v) = peso(w)+1 cuando peso(w) es impar El resultado es inmediato. Presentaremos un ejemplo más adelante junto a los códigos de Hamming. Patrón de error.- Sea C un código lineal de longitud N. Supongamos que se envía la palabra código w (por ejemplo w=10110) y se recibe la palabra v (por ejemplo v=00111). Llamaremos patrón de error a la palabra: e = w + v (Por ejemplo e = 10110 + 00111 = 10001) Es claro que el patrón de error tiene unos en las posiciones donde el ruido invierte los bits. El número de bits incorrectos -entre lo que se envía y lo que se recibe es-: peso(e). Es claro que si no hay inversiones el patrón de error es e=0. Por supuesto podemos escribir: v = w + e, o bien w = v + e Algoritmos de codificación/decodificación.- Dado un código lineal C de longitud N, supondremos que el algoritmo de codificación es sencillo y evidente: El mensaje original a1…ak se multiplica por la matriz generadora de C para obtener el mensaje codificado: w=[a1…ak]·G Por otro lado, cuando se recibe una secuencia v de N símbolos, necesitamos un algoritmo de decodificación (siguiendo reglas de decisión basadas en principios de decodificación) que indique qué hacemos con v. Es claro que si el síndrome s = v·HT = 0 estamos ante una palabra código recibida (lamentablemente existe la probabilidad de que el ruido haya sido tan severo que cambió la palabra código enviada por esta otra) que supondremos es la enviada originalmente. Si v no corresponde a una palabra código podemos apelar al principio de máxima posibilidad (o de mínima distancia o de máxima vecindad) para decidir cuál palabra código asociamos a la secuencia recibida. Un algoritmo elemental es calcular la distancia de v respecto de cada palabra código y elegir la que esté más próxima (o una de ellas si hay varias). Afortunadamente hay otros algoritmos que hacen lo mismo de un modo más interesante o más óptimo en función del espacio o el tiempo necesario de cálculo: 1) Algoritmo de decodificación basado en la matriz típica o arreglo estándar. Dado el código lineal C de M=2k palabras código, en el Anexo 3 mostramos que hay exactamente 2N-k co-conjuntos disjuntos que cubren 2N y que cada u  2N está únicamente en un co-conjunto. Llamaremos líder de un co-conjunto a la palabra de menor peso en él (si hay más de uno, se elige cualquiera). Si colocamos los co-conjuntos como filas de una matriz de la siguiente manera: - En cada fila colocamos el líder en la primera columna. - Ordenamos ascendentemente las filas según el peso de la primera columna. Es claro que en la primera fila está C. Los elementos en la columna j deben ser tales que corresponden a sumar el líder de cada fila con la palabra código wj. Llamaremos matriz estándar a la matriz así construida.

142

Ejemplo:

1 0 1 Sea C = { 000, 101, 011, 110 } con matriz generadora G =   0 1 1 Los co-conjuntos de C son: 000 + C = { 000, 101, 011, 110 } 010 + C = { 010, 111, 001, 100 } Su matriz estándar es (hemos puesto en negrita a los líderes):

000 101 011 110 010 111 001 100

Si v está en la columna j de la matriz estándar Entonces wj es la palabra código más cercana a v Demostración: Supondremos que v está en la fila i de la matriz. Llamemos vi al líder de dicha fila. Es claro que v está en el co-conjunto vi + C. Como v está en la columna j –por la forma de construir la matriz- resulta que: v = vi + wj. Es decir, vi = v + wj (*) Supongamos que wj no es la palabra código más cercana a v, es decir, wh d(v,wh)
Más aún, en seguida mostramos que si C corrige hasta t errores, es decir t=[(dC-1) /2], wj es la única palabra más cercana a v. Sea C un código lineal con distancia mínima dC que corrige hasta t=[(dC-1) /2] errores. Sea vi el líder de la fila i en la matriz estándar. Si v está en la columna j de la matriz estándar (en la fila i) y peso(vi)  t Entonces wj es la única palabra código más cercana a v Demostración: Sabemos que v = vi + wj. Es decir, vi = v + wj (*) También sabemos que wj es la palabra código más cercana a v. Supongamos que wj no es la única palabra código más cercana a v, es decir: wh d(v,wh)  d(v,wj) (**)

143

d(wj,wh)  d(wj,v) + d(v,wh) probado en la página 112  d(wj,v) + d(v,wj) por (**) = 2·d(v,wj) obvio = 2·peso(v+wj) pues d(v,wj)=peso(v+wj) = 2· peso(vi) por (*)  2·t por hipótesis  (dC-1) pues C corrige hasta t=[(dC-1) /2] errores < dC obvio  d(wj,wh) por definición de dC Es decir: d(wj,wh) < d(wj,wh). Contradicción que prueba el enunciado. Considerando el patrón de error y suponiendo que se envía w, se recibe: v=w+e El algoritmo da por sentado que v está en la columna j de la matriz: v = vi + wj = wj + vi y decide que se ha enviado wj. Esta decisión es correcta si y sólo si w=wj, es decir, si y sólo si e = vi. Así pues, se escogen como líderes las palabras de menor peso en cada co-conjunto, es decir, los líderes son los patrones de error más probables a ser detectados y/o corregidos. 2) Algoritmo de decodificación basado en el síndrome o en la tabla de síndromes. Es una versión resumida de la matriz estándar y por ello más óptima. En vez de almacenar toda la matriz estándar sólo preserva la primera columna de líderes, a la que adjunta una tabla (un vector columna) de síndromes. Se basa en los siguientes resultados. Sea C un código lineal. Sea w  C. Por la linealidad de C, la suma de dos palabras código es otra palabra código. Además siempre es posible escribir w como w = wi + wj donde wi,wj  C (por ejemplo recurriendo a wj = 0). Así pues: w puede expresarse como la suma de dos palabras código (a) v,v'  2N están en el mismo co-conjunto de C si y sólo si (v+v')  C Demostración: v,v'  2N están en el mismo co-conjunto si y sólo si v = u + wi v' = u + wj si y sólo si u = v + wi u = v' + wj si y sólo si v + wi = v' + wj si y sólo si v + v' = wi + wj si y sólo si v + v' = wñ si y sólo si v + v'  C

(b)

(donde u+C es el co-conjunto donde está v) por definición de co-conjunto

obvio

obvio obvio linealidad de C y (a); obvio

144

donde wñ=(wi+wj)  C

Sea C un código lineal con matriz de paridad H. Sean s,s' los síndromes de v,v'  2N. v,v' están en el mismo co-conjunto si y sólo si s = s' Demostración: v,v' están en el mismo co-conjunto si y sólo si (v+v')  C si y sólo si (v+v')·HT = 0 si y sólo si (v·HT + v'·HT) = 0 si y sólo si v·HT = v'·HT si y sólo si s = s'

por (b) resultado demostrado en el subtítulo síndrome propiedades de matrices obvio definición de síndrome y supuestos

Así pues todas las palabras código que están en el mismo co-conjunto (en la misma fila de la matriz estándar) tienen el mismo síndrome, en particular el mismo síndrome que su líder. El algoritmo de la matriz estándar asume que la secuencia v que se recibe está en la fila i, columna j de la matriz (en el co-conjunto vi+C), es decir: v = vi + wj = wj + vi Y decide que se ha enviado wj. Es claro que wj = v + vi. Es decir, en vez de buscar la palabra código que está al principio de la columna j (en la primera fila), podemos hacer el cálculo v + vi, es decir, sumar a lo que se recibe el líder de su co-conjunto. Como en ese caso los síndromes de v,vi son iguales (por lo que acabamos de demostrar), para identificar el co-conjunto (y su líder) al cual pertenece la secuencia recibida v, basta determinar el síndrome de v (que iguala al síndrome de vi). Ello se puede hacer así: - Construimos una tabla (columna) de líderes ordenada según el peso. - Al lado construimos una tabla con los síndromes correspondientes a cada líder La llamaremos tabla de síndromes. El algoritmo de decodificación basado en el síndrome es evidente: Al recibir v, calculamos su síndrome s = v·HT, buscamos s en la tabla de síndromes, tomamos el líder del co-conjunto al que pertenece v, es decir, el líder vi que está en la primera tabla al lado de s, hacemos el cálculo v + vi Y decidimos que se ha enviado wj = v + vi. Ejemplo: Sea C = { 0000, 1111 } con G =[ 1 1 1 1 ]

1 1 0 0 H = 1 0 1 0 1 0 0 1

145

dC=4

Tabla de líderes

Tabla de síndromes 0000 1000 0100 0010 0001 1100 1010 1001

000 111 100 010 001 011 101 110

Si se recibe v = 0100, el síndrome de v es s = 100, luego el líder buscado es vi = 0100. Decidimos que se ha enviado wj = v + vi = 0100 + 0100 = 0000. Distancia mínima de un código lineal a través de su matriz de paridad.Si C es un código lineal con distancia mínima dC y matriz de paridad H Entonces dC es el mínimo número de columnas linealmente dependientes de H Demostración : Sea w=w1w2...wN

 h11 ... h1N  ... ...  = [columna1 ··· columnaN] y sea H =  ... h(N - k )1 ... h(N - k )N 

Como w·HT = [w1·h11+…+ wN·h1N ··· w1·h(N-k)1+…+ wN·h(N-k)N] = [w1·h11 w1·h21 … w1·h(N-k)1] + ··· + [wN·h1N wN·h2N … wN·h(N-k)N] = w1•[h11 h21 … h(N-k)1] + ··· + wN•[ h1N h2N … h(N-k)N] = w1•(columna1)T + ··· + wN•(columnaN)T Entonces la ecuación w·HT = 0 puede reescribirse así: w1•(columna1)T + ··· + wN•(columnaN)T = 0 (*) Probamos atrás que si w  C entonces w·HT = 0. Es decir, si w  C entonces w1•(columna1)T + ··· + wN•(columnaN)T = 0 Cuando w0 (*) es una relación de dependencia lineal entre las columnas. Con más especificidad, las columnas que intervienen explícitamente en esta relación de dependencia lineal son aquellas para las que wi≠0. Resumiendo: Si w  C (w0) entonces hay una relación de dependencia lineal entre las columnas de H (específicamente entre aquellas para las que -correspondientemente- wi≠0). Como C es lineal: dC = min{ peso(w) / w  C, w≠0…0}. Es decir, dC es el menor número de unos de algún w  C (considerando todas las palabras código diferentes de 0). Pero entonces –por lo dicho antes-, dC es el menor número de columnas linealmente dependientes de H. Que es lo que queríamos demostrar. Cuando hablamos de un código lineal C  2N (donde está involucrado el campo binario Z2), el enunciado tiene un corolario por demás interesante.

146

En efecto, el menor número de columnas linealmente dependientes de H es 1 cuando la ecuación: wi•(columnai)T = 0 tiene solución o soluciones no triviales (es decir wi≠0). Pero en ese caso wi=1 y la ecuación es: (columnai)T = 0. De manera que dC=1 cuando H tiene una columna de ceros. Consideremos el caso dC=2. El menor número de columnas linealmente dependientes de H es 2 cuando la ecuación: wi•(columnai)T+wj•(columnaj)T = 0 tiene soluciones no triviales (es decir: wi,wj≠0) Pero en ese caso wi=wj=1 y la ecuación es: (columnai)T+(columnaj)T = 0 Como en Z2 el inverso de 0 es 0 y el de 1 es 1, la única forma de que tal ecuación se satisfaga es cuando la columnaj y la columnai son iguales. De manera que dC=2 cuando H tiene dos columnas iguales. El corolario es: Si C es un código lineal con matriz de paridad H Entonces la distancia mínima dC  3 cuando H tiene columnas diferentes y distintas de 0. Cota de Singleton (formulada por Richard Singleton).Si C es un código lineal de longitud N y mínima distancia dC Entonces dC  N - k + 1 Demostración: Sin pérdida de generalidad suponemos que la matriz generadora de C es G=[Ik × k : Ak × N-k] Cada fila de G es una palabra código w  C. Por la forma de G (matriz identidad y a la derecha la matriz Ak × N-k) el peso de cada fila es: peso(w)  N-k +1 (el 1 viene de Ik × k; N-k es el número de símbolos de las filas de A –no necesariamente todos unos-) Como dC = min{ peso(w) / w  C, w≠0…0}, es evidente que dC  N-k +1.

Códigos de Hamming.- Richard Hamming buscaba un método para construir códigos lineales correctores. El siguiente resultado es necesario para ello. Existe C un código lineal binario de longitud N y dimensión k que corrige t errores si y sólo si Existe una matriz (de paridad) H(N- k) × N de rango N-k donde cada grupo de 2t columnas es linealmente independiente. Demostración: Recordemos que el rango de una matriz es el número de filas linealmente independientes. 1) Si existe una matriz (de paridad) H(N- k) × N de rango N-k donde cada grupo de 2t columnas es linealmente independiente Entonces Existe C un código lineal binario de longitud N y dimensión k que corrige t errores. En efecto, dada la matriz H(N- k) × N donde todas sus filas son linealmente independientes. Sabemos que el núcleo de H es es un subespacio lineal de 2N: NH = { v  2N / H·vT = 0 } = { v  2N / v·HT = 0 } (en este caso NH es de dimensión k) Tomemos C=NH como el código lineal binario de longitud N. H es claramente la matriz de paridad de C.

147

Por otro lado, como cada grupo de 2t columnas de H es linealmente independiente, en el Anexo 3 indicamos que, si le añadimos otro elemento el conjunto resultante se torna linealmente dependiente-, es decir, cualquier conjunto de 2t+1 columnas de H es linealmente dependiente. En la página 146 demostramos que la distancia mínima dC de nuestro código lineal es el mínimo número de columnas linealmente dependientes de H. Por lo que concluimos que: dC = 2t+1. Lo que nos permite concluir que C corrige t errores. 2) Si existe C un código lineal binario de longitud N y dimensión k que corrige t errores Entonces existe una matriz (de paridad) H(N- k) × N de rango N-k donde cada grupo de 2t columnas es linealmente independiente. En efecto, sea H la matriz de paridad de C. Ya vimos –cuando introducimos la matriz generadora en forma canónica- que H es de rango N-k con dimensiones (N- k) × N. Sabemos que C corrige t errores si y sólo si dC  2t+1. Como C corrige t errores, entonces dC  2t+1. Además la distancia mínima es el mínimo número de columnas linealmente dependientes de H. Luego, el mínimo número de columnas linealmente dependientes de H es 2t+1. Entonces, a lo más 2t columnas de H son linealmente independientes. El resultado sigue. Hamming además requería que sus códigos sean perfectos. Describamos el trabajo para códigos binarios con t=1. Como el código debe ser perfecto, se alcanza la igualdad en el límite de Hamming t  N M·V(N,t)  2N, donde V(N,t) =    que con t=1 es V(N,1) = 1+N i 0  i  Además, siendo binario el código M=2k. Es decir, debe satisfacerse: 2k·(1+N) = 2N Que puede reescribirse así: 2N-k = N+1. O así: N = 2N-k – 1. Si llamamos r al número de bits de redundancia N-k tenemos que debe satisfacerse: N = 2r – 1. De acuerdo al enunciado con el que empezamos este apartado (con t=1) : Existe C un código lineal binario de longitud N y dimensión k que corrige 1 error si y sólo si Existe una matriz (de paridad) H(N- k) × N de rango N-k donde cada dos columnas son linealmente independientes, es decir: wi•(columnai)T+wj•(columnaj)T = 0 sólo tiene la solución trivial Es decir, con wi,wj≠0 (o lo que es lo mismo con wi=wj=1) la ecuación (columnai)T + (columnaj)T = 0 no tiene solución T T Es decir: (columnai) + (columnaj) ≠ 0 Ello significa (en el campo binario) que la columnaj y la columnai son diferentes y ninguna es de ceros. Resumiendo: existe C de longitud N y dimensión k que corrige 1 error si y sólo si existe una matriz H(N- k) × N de rango N-k donde cada par de columnas es diferente (y ninguna es la columna cero). Juntando ambos criterios, para construir un código lineal perfecto que corrija t errores: Debemos tener una matriz con r=N-k filas y N=2r–1 columnas las cuales son diferentes de a pares y ninguna es la columna cero; además debe verificarse que N=2N-k – 1.

148

Pero sólo hay 2r distintas columnas binarias de r posiciones (incluyendo la columna de ceros). Así pues la única forma de construir H es colocando todas las columnas binarias de longitud r (excluyendo la columna de ceros) en algún orden. De manera más informal podemos decir que H se construye colocando los números de 1 a N (en algún orden) en binario (con r posiciones) por columnas. Es claro que con esas condiciones se satisface: N=2N-k – 1 (pues 2r–1=N=2N-k – 1=2r–1), es decir, los códigos resultantes son perfectos.

Es sencillo verificar que tales matrices tienen rango r: Los números que son potencias de 2 están presentes en las columnas de H. Ellos sólo incluyen un 1 siendo el resto de sus símbolos ceros. Sin pérdida de generalidad podemos tomarlos como pivotes. Cualquier texto de Álgebra Lineal muestra que estos r pivotes constituyen el rango de H. El orden en que se coloquen las columnas no afecta a la distancia mínima y sólo devuelve códigos equivalentes (por permutación de columnas). En honor a Hamming estos códigos se denotan genéricamente como HN. Es claro que N=2N-k – 1 se satisface para varios valores de N y k, es el caso de (N,k) = (3,1), (N,k) = (15,11), etc. Ejemplo: Para (N,k) = (7,4) es evidente que se satisface 7 = N = 2N-k – 1 = 27-4 – 1 = 23 – 1 = 8 –1 = 7 Construimos la matriz de paridad colocando los números de 1 a 7 en binario por columnas. El orden no influye en lo esencial del código. Para diferentes órdenes los códigos resultantes son equivalentes. Sin embargo, hay otras ventajas eligiendo uno u otro orden. Si elegimos la siguiente colocación –con I a la derecha, es decir, en forma canónica-: 0 1 1 1 1 0 0  H = 1 0 1 1 0 1 0 1 1 0 1 0 0 1 Hallar la matriz generadora correspondiente G es inmediato.

Si elegimos la (intuitiva) colocación en secuencia tenemos: 1 2 3 4 5 6 7 0 0 0 1 1 1 1 H = 0 1 1 0 0 1 1 1 0 1 0 1 0 1 Para obtener la matriz generadora primero debemos colocar esta matriz de paridad en forma canónica (recordando las permutaciones entre columnas: 1 con 7, 2 con 6, 4 con 5), luego obtener inmediatamente la matriz generadora en forma canónica y a partir de ella volver a construir la matriz generadora buscada, permutando las columnas en orden inverso (como ya vimos antes).

149

1 0 El resultado es: G =  1  1

1 0 1 0 0 1 1 0 1 0 1 0 1 1 0 0 0 0  0 0 1 1 0 0

Cuyo código con dC=3 es el siguiente: pre-entrada palabra código 0000 0000000 0001 1001100 0010 1110000 0011 0111100 0100 0101010 0101 1100110 0110 1011010 0111 0010110

pre-entrada 1000 1001 1010 1011 1100 1101 1110 1111

palabra código 1101001 0100101 0011001 1010101 1000011 0001111 0110011 1111111

Todos los códigos de Hamming para t=1 tienen distancia mínima dC=3.Obviaremos el caso trivial (N,k) = (1,0). El siguiente par de valores que satisface la ecuación N=2N-k – 1 es (N,k) = (3,1), es claro que hay otros infinitos valores que satisfacen esta condición. Todos ellos tienen N  3. Así las columnas de las matrices H d elos códigos de Hamming incluyen la que debe llenarse con el 1, con el 2 y la que debe llenarse con el 3 (posiblemente hay más columnas). Se sabe que la distancia mínima de un código lineal se puede calcular a través de su matriz de paridad. De hecho es el mínimo número de columnas linealmente dependientes de H. Más aún, vimos que dC  3 cuando H tiene columnas diferentes y distintas de 0, como es el caso de las matrices de paridad de los códigos de Hamming. En ellas es evidente que tres columnas son linealmente dependientes: Si sumamos la columna “contiene” al 1 con la del 2 obtenemos la columna c3 que “contiene” al 3. Es decir: [ wi•(columna idel1)T+wj•(columnajdel2)T] + wñ•(columnañdel3)T = 0 Tiene la solución no trivial wi = wj = wñ = 1. Luego, el mínimo número de columnas linealmente dependientes de H es 3. Es decir, dC=3 en los códigos de Hamming (para t=1). En rigor, si anotamos las columnas de una matriz H genérica (con los números de 1 a N anotados secuencialmente por columnas) así:  0 0 ... 1  ... ... ... ...  La suma (módulo 2) de cualquier par de columnas devuelve otra. H =  0 1 ... 1     1 0 ... 1  Así, el mínimo número de columnas linealmente dependientes de H es 3 como dijimos.

Decodificación por síndrome en los códigos de Hamming.- Trabajaremos la decodificación de palabras recibidas con hasta un error respecto de las enviadas.

150

Sea C un código lineal de Hamming de longitud N con matriz de paridad H. Sea e  2N tal que peso(e) = 1 (e contiene sólo ceros excepto un 1 en la posición j) Entonces e·HT = cjT (donde cj es la columnaj de H) Demostración: Recordemos que las columnas de H consisten de secuencias que pueden interpretarse como los números binarios de 1 a N (en algún orden). Denotaremos la palabra e genéricamente así: e = [0...0 1 0...0] (el 1 en la posición j)  h11 ... h1N  ... ...  Sea H =  ... h(N - k )1 ... h(N - k )N 

 h11 ... h(N - k )1  Luego, e·H = [0...0 1 0...0] ·  ... ... ...  = [h1j h2j ... h(N-k)j] = cjT h1N ... h(N - k )N  T

Si se envía la palabra código w, recordemos que se recibe v = w + e. Donde e es el patrón de error. El síndrome de v es: s = v·HT por definición = (w+e)·HT pues v = w+e T T = w·H + e·H propiedades de matrices = 0 + e·HT resultado demostrado en el subtítulo síndrome T = e·H obvio Es decir, el síndrome está en función del patrón de error. Si consideramos patrones de error de peso(e) = 1 (si no hay inversiones el patrón de error es obviamente e = 0), es claro –por los últimos dos resultados- que: s = e·HT = cjT (donde cj es la columnaj de H) Como las columnas de H son diferentes, palabras de peso 1 diferentes tienen síndromes diferentes. Recordemos que v,v' están en el mismo co-conjunto si y sólo si s = s'. Es lo mismo decir que s  s' si y sólo si v,v' están en co-conjuntos distintos. Luego, todas las palabras de peso 1 están –cada una- en diferentes co-conjuntos. Así pues podemos tomar las palabras de peso 1 como líderes de cada co-conjunto. Luego las tablas necesarias en nuestro algoritmo se forman así: Tabla de líderes

Tabla de síndromes

La secuencia de ceros junto a Palabra(s) e de peso 1 (e tiene ceros excepto un 1 en la posición j)

Secuencia de ceros junto a Columna(s) j de H

151

Sin embargo, si la matriz de paridad H para el código de Hamming se construye siguiendo la (intuitiva) colocación en secuencia el algoritmo de decodificación se simplifica aún más. En efecto, cuando recibimos la palabra v, obtenemos su síndrome s = v·HT, luego buscamos tal síndrome en la tabla de síndromes, tomamos el líder vi del co-conjunto que está en la primera tabla al lado de s, hacemos el cálculo v + vi. Y decidimos que se ha enviado wj = v + vi. Pero el líder vi del co-conjunto no es otra cosa que una palabra e de peso 1 (vi = e). De manera que la suma (v + vi) no es otra cosa que (v + e) –donde e tiene un 1 en la posición j -, que no es otra cosa que cambiar el bit de la posición j de v ¿Cuál posición? La que corresponda a la columna j de H. En el caso señalado, H tiene la colocación en secuencia de los número de 1 a N en binario, las columnas j corresponden a los números j (en decimal). Luego el algoritmo se simplifica así: Cuando recibimos la palabra v, obtenemos su síndrome s = v·HT. s se considera un número binario, lo convertimos a decimal –el resultado es digamos j-. Finalmente corregimos (invertimos) el bit en la posición j de v. Y decidimos que esa es la palabra código wj enviada. Ejemplo: 1 2 3 4 5 6 7 0 0 0 1 1 1 1 Para H = 0 1 1 0 0 1 1 1 0 1 0 1 0 1 Si se recibe v = 1100100, el síndrome de v es s = v·HT = 110 = (6)10 Luego invertimos el bit en la posición j = 6 de v, decidiendo que se envió w = 1100110.

1 1 0 1 0 0 1 0 1 0 1 0 1 0   cuyo código Código dual de un código de Hamming.- Para G =  1 1 1 0 0 0 0   1 0 0 1 1 0 0 de Hamming correspondiente C se encuentra descrito en su integridad en dicho apartado, sabemos que su código dual se obtiene a partir de la correspondiente matriz de paridad H 0 0 0 1 1 1 1 que en este caso es: H = 0 1 1 0 0 1 1 1 0 1 0 1 0 1 El código dual íntegro es: C┴ = { 0000000, 1010101, 0110011, 1100110, 0001111, 1011010, 0111100,1101001 }

152

Código expandido de un código de Hamming.1 1 0 1 0 0 1 0 1 0 1 0 1 0   cuyo código de Hamming correspondiente C, con Para G =  1 1 1 0 0 0 0   1 0 0 1 1 0 0 dC=3, se encuentra descrito en su integridad en dicho apartado, sabemos que su código expandido se obtiene a partir de la siguiente matriz generadora (tal como se indica en el apartado de códigos expandidos): 1 1 0 1 0 0 1 0 0 1 0 1 0 1 0 1   Ge =  1 1 1 0 0 0 0 1   1 0 0 1 1 0 0 1 El código expandido íntegro es: Ce = { 00000000, 10011001, 11100001, 01111000, 01010101, 11001100, 10110100, 00101101, 11010010, 01001011, 00110011, 10101010, 10000111, 00011110, 01100110, 11111111 } Además como se indica en dicho apartado su distancia mínima es dCe = dC+1 pues dC es impar. Es decir, como dC=3, resulta que: dCe = 4.

153

CÓDIGOS CÍCLICOS Sea C un código lineal. C es un código cíclico si la rotación de una palabra código es también una palabra código. Ejemplos: Sea el código lineal C = { 000, 111 } La rotación de la palabra código 000 es 000. La rotación de la palabra código 111 es 111. Es claro que cualquier rotación de una palabra código es una palabra código, luego C es cíclico. Sea el código lineal C = { 00, 10 } La rotación de la palabra código 10 es: 01. 01 no es una palabra código. Luego, C no es cíclico. Sea el código lineal C = { 000, 101, 011, 110 } La rotación de la palabra código 000 es 000. La rotación de la palabra código 101 es 110. La rotación de la palabra código 110 es 011. La rotación de la palabra código 011 es 101. No hay más rotaciones. Es claro que cualquier rotación de una palabra código es una palabra código, luego C es cíclico. Es evidente –de la definición de código cíclico y del concepto de rotación- que las rotaciones pueden ser más de una vez y a la izquierda o a la derecha. Tratar a un código (debido a que posee ciertas carácterísticas) como a un espacio lineal permite derivar propiedades y resultados que de otro modo resulta complicado. Al trabajar con códigos cíclicos binarios de longitud N (C  2N) haremos algo semejante. Identificaremos cada palabra (sea código o no) con un polinomio de la siguiente manera: b = b1...bN

se identifica con

b(x) = b1x0 + b2x1 + ... + bNxN-1

Donde la suma y multiplicación de polinomios son las habituales (con coeficientes en Z2). Técnicamente estamos haciendo una transformación que denominaremos polinomial, donde introducimos la indeterminada u operador de posición de bit: x. Nótese que las palabras se identifican con polinomios de grado menor a N. Ejemplo: Palabras código de C 000 101 011 110

Polinomios asociados 0 1 + x2 x + x2 1+x

154

En el Anexo 4 (que debe leerse) se muestra que Z2N[x]/(xN+1) es un anillo, donde Z2N[x] denota al conjunto de todos los polinomios de grado menor a N (con coeficientes en Z2), y donde se trabaja con la multiplicación de polinomios módulo (xN + 1). El hecho de que Z2N[x]/(xN+1) sea un anillo permite –en base a la identificación de palabras con polinomios- destacar algunas semejanzas entre lo que sucede con palabras y lo que sucede con polinomios. Nótese que: Con b = b1b2...bN-1bN una rotación de b es: bNb1b2 ... bN-1 1) El polinomio asociado a b es: b(x) = b1x0 + b2x1 + ... + bN-1xN-2 + bNxN-1 = b1 + b2x1 + ... + bN-1xN-2 + bNxN-1 2) x × b(x) = x · b(x) mod (xN + 1) = x · [b1x0 + b2x1 + ... + bN-1xN-2 + bNxN-1] mod (xN + 1) = [b1x + b2x2 + ... + bN-1xN-1 + bNxN] mod (xN + 1) = bN + b1x + b2x2 + ... + bN-1xN-1 Que no es otra cosa que el polinomio asociado a una rotación de b. 3) Se sigue que: xi · b(x) mod (xN + 1) es el polinomio asociado a i rotaciones de b 4) 1 · b(x) mod (xN + 1) = b(x) es el polinomio asociado a una rotación nula de b Luego, por la distribución del producto (·) respecto de la suma y la reducibilidad de mod: Sea q(x)Z2N[x]/(xN+1) q(x) × b(x) = q(x) · b(x) mod (xN + 1) es el polinomio asociado a una suma de rotaciones de b = b1...bN Ideales y códigos cíclicos.Sea Cp el conjunto de polinomios asociados a las palabras código del código lineal C (de longitud N). Recordando el concepto de ideal visto en el Anexo 4, tenemos el siguiente resultado: El código lineal C es cíclico si y sólo si Cp es un ideal. Demostración: Previamente veamos este ejemplo. Considerando C 000 101 011 110 Una rotación de 110 es: 011 Una rotación de 011 es: 101

Considerando Cp 0 1 + x2 x + x2 1+x x · [1 + x] mod (x3 + 1) = x + x2 mod (x3 + 1) = x + x2 x · [x + x2] mod (x3 + 1) = x2 + x3 mod (x3 + 1) = 1 + x2

155

La multiplicación de cualquier polinomio en Z23[x]/(x3+1) por un elemento de Cp es otro polinomio en Cp. Por ejemplo con [1 + x + x2] y el polinomio asociado a 011: [1 + x + x2] · [x + x2] mod (x3 + 1) = 1 · [x + x2] mod (x3 + 1) + x · [x + x2] mod (x3 + 1) + x2 · [x + x2] mod (x3 + 1) = [x + x2] + [1 + x2] + [1 + x] =0 Note que en términos de una suma de rotaciones de la palabra código 011: 1 · [x + x2] mod (x3 + 1) + x · [x + x2] mod (x3 + 1) + x2 · [x + x2] mod (x3 + 1) corresponde a: 011 + 101 + 110 = 000 Retomando la demostración. i) Sea Cp el conjunto de polinomios asociados a las palabras código de C. Si el código lineal C es cíclico Entonces Cp es un ideal. Dado que C es lineal y cíclico es claro que: - La suma de dos palabras código es otra palabra código - La rotación de una palabra código es también una palabra código Sea w(x)Cp el polinomio asociado a w=w1w2...wN-1wNC. Ya vimos que x × w(x) = x · w(x) mod (xN + 1) = wN + w1x + w2x2 + ... + wN-1xN-1 Es claro que wN + w1x + w2x2 + ... + wN-1xN-1 es el polinomio asociado a wNw1w2...wN-1, que es una rotación de w y como wC y C es cíclico resulta que wNw1w2...wN-1C. Como Cp es el conjunto de polinomios asociados a las palabras código de C se deduce que [x × w(x)]Cp. El mismo razonamiento repetido, muestra que [xi × w(x)]Cp. Finalmente, la distribución de × sobre + y la linealidad de C permiten ver que, dada b una palabra de longitud N arbitraria y b(x) su polinomio asociado: w(x)Cp b(x)Z2N[x]/(xN+1) [b(x) × w(x)]Cp Es decir, que Cp es un ideal. ii) Sea C el conjunto de palabras código asociadas al conjunto de polinomios Cp. Si Cp es un ideal Entonces el código C es cíclico. Sean u,vC, palabras código asociadas a los polinomios u(x),v(x)Cp. Como Cp es un ideal, sabemos que (Cp,  ) es un subgrupo abeliano de (Z2N[x],  ), es decir, [u(x)  v(x)]Cp. Dado que C es el conjunto de palabras código asociadas a los polinomios de Cp, resulta que la palabra código w asociada a [u(x)  v(x)] es tal que wC. Pero es evidente que los coeficientes de [u(x)  v(x)] son exactamente los componentes de [u + v]. Es decir, w = [u + v], con wC. Luego, C es lineal. Dado que Cp es un ideal, por definición: w(x)Cp b(x)Z2N[x]/(xN+1) w(x)×b(x)Cp. Sea w=w1...wNC la palabra código asociada a w(x)Cp. Por ser Cp un ideal: b(x)×w(x)Cp. Cuando b(x) = x, sabemos que b(x)×w(x) = x × w(x) = wN + w1x + w2x2 + ... + wN-1xN-1, es el polinomio asociado a wNw1w2...wN-1. Como [x × w(x)]Cp y C es el conjunto de palabras código asociadas al conjunto de polinomios Cp, resulta que wNw1w2...wN-1C.

156

Es decir, una rotación de una palabra código de C también es una palabra código de C. Bajo un razonamiento análogo, con b(x) = xi, se deduce que i rotaciones de una palabra código de C también es una palabra código de C. Es decir, C es cíclico. Ambos incisos i) y ii) prueban el enunciado; el cual muestra que técnicamente estamos hablando de un isomorfismo.

Es claro que el ideal Cp es un subespacio lineal, pues: - (Z2N[x], {0, 1},  , +, ×, •) es un espacio lineal sobre F2 - Cp  Z2N[x] - (Cp,  ) es un subgrupo abeliano de (Z2N[x],  ) - (b•p(x))  Cp para p(x)  Cp y b  {0, 1} Demostraremos ahora algunos resultados importantes: Sea C{0} un código cíclico de longitud N. Sea el ideal Cp el conjunto de polinomios asociados a C. Si Cp es un ideal Entonces 1) Hay un único polinomio w(x) de grado mínimo r0 en Cp. 2) Cp  { b(x) · w(x) / gr(b(x)) < N − r} [gr(b(x)): el grado de b(x)] 3) { b(x) · w(x) / gr(b(x)) < N − r}  Cp. 4) Cp = {b(x) · g(x) / gr(b(x)) < N − r}. Es decir, g(x) genera Cp. 5) g(x) | (xN + 1). Es decir, g(x) es un factor de (xN + 1) 6) { g(x), x ×g(x), ... , xk-1 × g(x) } es una base de Cp [donde N-k = r = gr(g(x))]. 7) La dimension de Cp es k. Demostración: 1) Supongamos que en Cp hay dos polinomios de grado mínimo r, w(x) y v(x): w(x ) = w1 + w2x + ... + wrxr-1 + wr+1xr (con wr+1=1) v(x ) = v1 + v2x + ... + vrxr-1 + vr+1xr (con vr+1=1) Es claro que w(x) + v(x) = (w1 + v1) + ... + (wr+vr)xr-1 + 0 Como Cp es un subespacio lineal, w(x)+v(x)Cp. Luego, hay un polinomio en Cp de grado menor que r. Esta contradicción prueba el enunciado. 2) Sea w(x) el único polinomio de grado mínimo r en Cp. Sea v(x)Cp. Sea res(x) el residuo de la división de v(x) entre w(x); sea b(x) el cociente de la misma. Es decir, v(x) = [b(x) · w(x)] + res(x) con el grado de res(x) menor al grado de w(x) obviamente gr(b(x)) < N − r Luego, res(x) = [b(x) · w(x)] + v(x) Como Cp es un ideal [b(x) · w(x)]=[b(x) × w(x)]Cp. Como en 1), ([b(x) · w(x)] + v(x))Cp, es decir res(x)Cp. Pero w(x) tiene grado mínimo r0 y res(x) tiene grado menor a w(x). Luego, res(x) = 0. Por lo tanto, v(x) = b(x) · w(x). Es decir, v(x){ b‟(x) · w(x) } Lo que prueba el enunciado.

157

3) Sea w(x) el único polinomio de grado mínimo r. Sea b(x) un polinomio tal que gr(b(x)) < N − r. Sea [b(x) · w(x)] un polinomio múltiplo de w(x). Es decir, sea [b(x)·w(x)]{b‟(x)·w(x)}. Es evidente que gr[b(x) · w(x)] < N. Luego, b(x) · w(x) = b(x) × w(x) = w(x) × b(x). Como Cp es un ideal [w(x) × b(x)]Cp. Lo que prueba el enunciado. 4) De 2 y 3 se deduce que Cp = { b(x) · w(x) / gr(b(x)) < N − r}. Al polinomio w(x) se lo conoce más como el polinomio generador de Cp. Este polinomio de grado mínimo r0 en Cp, es denotado de manera más común como g(x). Luego, Cp = {b(x) · g(x) : gr(b(x)) < N − r}. Otros autores denotan esto así: Cp = 5) Si g(x) es el polinomio de grado mínimo en Cp, es claro que [xN-r · g(x)] es de grado N. Sea [xN-r × g(x)] = xN-r · g(x) mod (xN + 1) = h(x). Es decir: xN-r · g(x) = (xN + 1) + h(x) (i) N-r Como g(x)Cp y Cp es un ideal, es claro que [x × g(x)]=h(x)Cp. Luego, por 2): h(x) = b(x) · g(x) (ii) Entonces: xN-r · g(x) + h(x) = (xN + 1) + h(x) + h(x) por (i) N = x +1 obvio (iii) Por lo tanto: xN-r · g(x) + h(x) = xN-r · g(x) + b(x) · g(x) por (ii) = xN + 1 por (iii) De donde se deduce que: xN-r · g(x) + b(x) · g(x) = [xN-r + b(x)] · g(x) = xN + 1 Es decir, g(x) es un factor de (xN + 1). Nótese que g(x)  x, pues x no divide a (xN + 1). Representemos a g(x) así: g(x) = g0x0 + g1x1 + ... + grxr Nótese también que g0  0, pues en tal caso g(x) = x · (g1 + g2x ... + gr-1xr-1), y como g(x) es un factor de (xN + 1), esto mostraría que (g1 + g2x ... + gr-1xr-1) y (x) también lo son, cosa descartada cuando menos en el último caso. 6) Como Cp es un subespacio lineal es plausible pensar en una base para él. Probaremos que: 6.1) { g(x), x ×g(x), ... , xk-1 × g(x) } es un conjunto linealmente independiente. En efecto, como N-k = r = gr(g(x)), es claro que: para 0 i k-1, xi × g(x) = xi · g(x) mod (xN + 1) = xi · g(x) pues gr(xi · g(x))  k-1 + r = k-1 + N-k = N - 1 (< N) También es claro, por el inciso 4, que: xi × g(x)Cp Sea la siguiente ecuación: a0g(x) + a1[x ×g(x)] + ... + ak-1[xk-1 × g(x)] = 0

158

Que es equivalente a: a0g(x) + a1[x · g(x) mod (xN + 1)] + ... + ak-1[xk-1 · g(x) mod (xN + 1)] = 0 Que es equivalente a: a0[g(x) mod (xN + 1)] + a1[x·g(x) mod (xN + 1)] +...+ ak-1[xk-1 ·g(x) mod (xN + 1)] = 0 Que es equivalente a: [a0 g(x) + a1 x·g(x) +...+ ak-1 xk-1 ·g(x)] mod (xN + 1) = 0 Pero gr([a0 g(x) + a1 x·g(x) +...+ ak-1 xk-1 ·g(x)]) < N De manera que el único modo en que [a0 g(x) + a1 x·g(x) +...+ ak-1 xk-1 ·g(x)] mod (xN + 1) = 0 es para 0 i k-1: ai = 0 Por lo tanto, { g(x), x ×g(x), ... , xk-1 × g(x) } es linealmente independiente. 6.2) Cp = gen{ g(x), x ×g(x), ... , xk-1 × g(x) } i) Si v(x)Cp, entonces –por 4- v(x) = b(x) · g(x) con gr(b(x)) < N − r = k. Luego, b(x) = b0x0 + b1x1 + ... + bN-r-1xN-r-1 Es decir, v(x) = [b0x0 + b1x1 + ... + bN-r-1xN-r-1] · g(x) = b0 x0· g(x) + b1 x1 · g(x) + ... + bk-1 xk-1 · g(x) Así, v(x) es una combinación lineal finita de { g(x), x ×g(x), ... , xk-1 × g(x) }. Es decir, v(x)gen{ g(x), x ×g(x), ... , xk-1 × g(x) }. ii) Si v(x)gen{ g(x), x ×g(x), ... , xk-1 × g(x) }, entonces: v(x) = b0 g(x) + b1 x1 × g(x) + ... + bk-1 xk-1 × g(x) = b0 · g(x) + b1 x1 · g(x) + ... + bk-1 xk-1 · g(x) por lo visto en 6.1 i Es claro, por el inciso 4, que [x ·g(x)]Cp. Como Cp es un subespacio lineal, [b0 · g(x) + b1 x1 · g(x) + ... + bk-1 xk-1 · g(x)]Cp. Es decir, v(x)Cp. Ambos incisos prueban el enunciado 7) Dado que el número de elementos de { g(x), x ×g(x), ... , xk-1 × g(x) } es k, es obvio a partir del inciso 6 que: dim(Cp) = k. Un octavo resultado se añade a los siete anteriores. 8) Si C{0}es un código cíclico de longitud N Entonces dim(C) = k y la matriz generadora de C se puede escribir así: g0 g1 ... gr 0 0 ... 0   0 g0 g1 ... gr 0 ... 0    G =  ... ... ... ... ... ... ... ... g(x) = g0x0 + g1x1 + ... + gr-1xr-1 + grxr    0 ... 0 g0 g1 ... gr 0   0 ... 0 0 g0 ... gr -1 gr  Demostración: Recordemos que el ideal Cp es el conjunto de polinomios asociados a C. Sea g(x) = g0x0 + g1x1 + ... + gr-1xr-1 + grxr, el polinomio generador de Cp. Como dim(Cp)=k, y Cp es un isomorfismo de C, entonces dim(C)=k.

159

Este hecho también puede deducirse del siguiente modo: Sea

g0 0  G =  ...  0  0

g1 ... gr

0

...

g0 g1 ... gr 0 ... ... ... ... ...

... ...

... ...

0 0

0

g0 g1 ... gr 0 g0 ... gr -1

0 0  ...  0 gr 

 g(x)   x·g(x)      x 2 ·g(x)    ...    x N- r-1 ·g(x) 

Sea g0g1...gr-1gr00...0C la palabra código representada por g(x). Es claro que [xi · g(x)] son polinomios que representan rotaciones de w, y como C es cíclico, dichas palabras pertenecen a C. Es decir, las filas de G representan palabras que pertenecen a C. En el Anexo 3 dijimos que la dimensión del espacio de las filas de G es el número de pivotes en su forma escalonada, en nuestro caso –dado que g00- este número es evidentemente k. Sólo resta probar que G genera C, es decir, gen(G) = C, es decir, que: gen({g0g1...gr-1gr00…0, 0g0g1...gr-1gr0…0, … , 0…0g0g1...gr-1gr0, 0…00g0g1...gr-1gr}) = C Ello es cierto pues: vC si y sólo si v(x)Cp pues Cp consta de los polinomios asociados a C si y sólo si v(x) = b(x) · g(x) por 4) 0 1 k-1 si y sólo si v(x) = b0 x · g(x) + b1 x · g(x) + ... + bk-1 x · g(x) por 6.2) i) si y sólo si v = b0 g0g1...gr-1gr00...0 + b1 0g0g1...gr-1gr0...0 + ... + bk-1 0...00 g0g1...gr-1gr si y sólo si vgen({ g0g1...gr-1gr00…0, 0g0g1...gr-1gr0…0, … , 0…0g0g1...gr-1gr0, 0…00g0g1...gr-1gr }) De toda la anterior argumentación se deduce que: La matriz generadora de C se puede escribir como G. Ejemplo: Para N=3 C 000 101 011 110

Nótese que 0 = 0 · g(x) 2 1 + x = (1 + x) · g(x) x + x2 = x · g(x) 1+x = 1 · g(x)

Cp 0 1 + x2 x + x2 1+x

El único

polinomio de grado mínimo r = 1 (0) en Cp es: g(x) = 1 + x g(x) es el polinomio generador de Cp. Nótese que (1+x+x2) · g(x) = xN + 1 1 1 0 La matriz generadora de C es: G =   donde dim(C) = k = 2 0 1 1  Estrictamente hablando g(x) es el polinomio generador del ideal Cp (no de C), pero como la identificación de cada palabra con un polinomio es 1-1, en adelante ignoraremos las distinciones rígidas entre C y Cp.

160

Un noveno resultado se añade a los ocho anteriores. 9) Si g‟(x) es un factor de (xN + 1) Entonces g‟(x) es el polinomio generador de algún código cíclico C Demostración: Sea N-k = r = gr(g‟(x)). Sea Sp = { g‟(x) × q(x) / q(x)Z2N[x]/(xN+1) } En el Anexo 4 vimos que Sp es un ideal. Supongamos que g‟(x) no es el polinomio de grado mínimo en Sp , es decir, hay un otro polinomio b(x) [con b(x)g‟(x)] de grado mínimo en Sp tal que gr(b(x))
161

Mostraremos ahora que lo que se puede hacer en C (con la matriz G) puede hacerse en Cp a través del polinomio g(x). En efecto, sea Gk × N la matriz generadora del código cíclico C. Recordemos que las palabras código de C se obtienen multiplicando: [a1 … ak]·G donde a1...ak es una secuencia de longitud k. Sea g(x) el polinomio generador de Cp. Si G se construye a partir de g(x) como en 8), consideremos lo siguiente: g0 g1 ... gr 0 0 ... 0   0 g0 g1 ... gr 0 ... 0    i) [a1 … ak]·G = [a1 … ak] ·  ... ... ... ... ... ... ... ...    0 ... 0 g0 g1 ... gr 0   0 ... 0 0 g0 ... gr -1 gr  = [ a1g0 a1g1 + a2g0 a1g2 + a2g1 + a3g0 ... ak-2gr + ak-1gr-1 + akgr-2 ak-1gr + akgr-1 akgr ]T donde hemos escrito el resultado como un vector columna transpuesto. ii) a(x)·g(x) = [ a1x0 + a2x + ... + ak-1xk-2 + ak xk-1 ] · [ g0x0 + g1x1 + ... + gr-1xr-1 + grxr ] = (a1g0)x0 + (a1g1 + a2g0)x + (a1g2 + a2g1 + a3g0)x2 … + (ak-2gr + ak-1gr-1 + akgr-2)xN-3 + (ak-1gr + akgr-1)xN-2 + (akgr)xN-1 Nótese que i) y ii) devuelven resultados equivalentes, uno en términos de palabras código y otro en términos de sus polinomios asociados [ los coeficientes del polinomio resultante en ii) son los componentes de la palabra código resultante en i) ].

Veremos ahora cómo podemos hacer una analogía con polinomios respecto de lo que hacíamos con matrices y/o palabras código. Trabajando con polinomios en Cp

Trabajando con matrices en el código C Dado C obtenemos la matriz generadora G así: Las palabras de C son las filas de una matriz. Se halla la forma escalonada de C, mediante operaciones elementales sobre filas (Gauss) y recogiendo sólo las filas diferentes de cero.

Dado Cp obtenemos el polinomio generador g(x) así: Elegimos el polinomio de menor grado como g(x).

162

Trabajando con polinomios en Cp

Trabajando con matrices en el código C Dada la matriz G se obtiene su matriz de paridad H, así:

Dado el polinomio g(x) se obtiene su polinomio de paridad h(x), así:

Obtenga la forma canónica Gc=[ I : A ] de G, luego Hc=[ AT : I ] y luego H aplicando en orden inverso las permutaciones de columnas.

Como g(x) divide a (xN + 1), entonces (xN + 1) = g(x) · h(x) Es decir, h(x) = (xN + 1) / g(x).

El código dual C┴ se obtiene a partir de su matriz generadora H, que es la matriz de paridad de G.

El ideal dual Cp┴ se obtiene a partir de su polinomio generador hR(x), llamado el polinomio recíproco de h(x): hR(x) = xk · h(1/x)

Dada la matriz Gk × N generar el código C así:

Dado el polinomio g(x) con gr(g(x))= r =N-k generar Cp así:

[a1 … ak]·G

donde a1...ak a(x)·g(x) es una secuencia de longitud k

con gr(a(x))
También se denomina a esto codificación de También se denomina a esto codificación de a1 … ak. a(x).

La primera y cuarta analogías ya fueron demostradas. Las otras las probamos ahora.

Sea g(x) el polinomio generador de Cp. h(x) es el polinomio de paridad de Cp. O, lo que es lo mismo: w(x) × h(x) = 0 si y sólo si w(x)Cp Demostración: i) Si w(x)Cp Entonces w(x) × h(x) = 0 En efecto. Como w(x)Cp, w(x)=a(x)·g(x). Luego, w(x) × h(x) = a(x)·g(x) × h(x) = a(x)·g(x)·h(x) mod (xN+1) por definición de × = a(x)·(xN+1) mod (xN+1) pues (xN+1)=g(x)·h(x) =0 obvio ii) Si w(x) × h(x) = 0 Entonces w(x)Cp En efecto. Como w(x) × h(x) = w(x) · h(x) mod (xN+1). Por hipótesis: w(x) · h(x) mod (xN+1) = 0. Es decir: w(x) · h(x) = q(x) · (xN+1). Es decir: w(x) · h(x) = q(x) · g(x) · h(x) Dividiendo ambos lados de la expresión por h(x), tenemos: w(x) = q(x)·g(x) 163

Aunque h(x) es el polinomio de paridad de Cp, el isomorfismo que construimos no preserva el producto interno. De manera que el ideal C‟p generado por h(x) no es el dual de Cp (en realidad es un ideal equivalente a él). Por ello es necesario el siguiente resultado. Si g(x) es el polinomio generador de Cp [con (xN+1) = g(x)·h(x)] y hR(x) = xk · h(1/x) Entonces hR(x) es el polinomio generador de Cp┴ (se entiende que gr(g(x))=r) Demostración: Requerimos el siguiente resultado previo: Denotaremos por roti(b) la rotación de b i veces. Por ejemplo rot2(1110)=1011. Sean a(x),b(x) los polinomios asociados las palabras a,b (de longitud N). Para b=b0b1...bN-1, sea b’=bN-1...b1b0. a(x) × b(x) = 0 si y sólo si i a º roti(b’) = 0 Demostración: Veamos un ejemplo pequeño que aporte claridad, antes de la demostración general. Trabajemos para N=3 con a(x) = a0 + a1x + a2x2 y b(x) = b0 + b1x + b2x2 Es claro que: a(x) × b(x) = a(x) · b(x) mod (x3+1) = [ (a0 + a1x + a2x2) · (b0 + b1x + b2x2) ] mod (x3+1) = [ a0b0 + (a0b1+a1b0)x + (a0b2+a1b1+a2b0)x2 + (a1b2+a2b1)x3 + (a2b2)x4 ] mod (x3+1) en Z2[x] se obtiene [p(x) mod (xN+1)] reemplazando xN por 1 en p(x) = [ a0b0 + (a0b1+a1b0)x + (a0b2+a1b1+a2b0)x2 + (a1b2+a2b1) + (a2b2)x ] = [ (a0b0+a1b2+a2b1) + (a0b1+a1b0+a2b2)x + (a0b2+a1b1+a2b0)x2 ] (*) También es claro que: Con a=a0a1a2 y b’=b2b1b0 a º b’ = a º rot0(b’) = (a0a1a2) º (b2b1b0) = (a0b2+a1b1+a2b0) (**) a º rot1(b’) = (a0a1a2) º (b0b2b1) = (a0b0+a1b2+a2b1) (**) 2 a º rot (b’) = (a0a1a2) º (b1b0b2) = (a0b1+a1b0+a2b2) (**) Nótese que los coeficientes de (*) son iguales a los valores en (**). Para este ejemplo, es evidente que a(x)×b(x) = 0 si y sólo si i a º roti(b’) = 0. Exactamente lo mismo sucede si hacemos las rotaciones sobre a en vez de sobre b’. Veamos ahora el caso general para cualquier valor de N. Para b=b0b1...bN-1, sea b’=bN-1...b1b0. Sea a=a0a1...aN-1 Sea a(x) = a0 + a1x + ... + aN-1xN-1. Sea b(x) = b0 + b1x + … + bN-1xN-1. Es claro que: a º rot0(b’) = (a0a1... aN-2aN-1) º (bN-1bN-2...b1b0) = (a0bN-1+a1bN-2+…+aN-2b1+aN-1b0) a º rot1(b’) = (a0a1... aN-2aN-1) º (b0bN-1 ... b2b1) = (a0b0+a1bN-1+…+aN-2b2+aN-1b1) … a º rotN-1(b’) = (a0a1... aN-2aN-1) º (bN-2bN-3...b0bN-1) = (a0bN-2+a1bN-3+…+aN-2b0+aN-1bN-1) También es claro que: a(x) × b(x) = a(x) · b(x) mod (xN+1) = [ (a0 + a1x + ... + aN-1xN-1) · (b0 + b1x + … + bN-1xN-1) ] mod (xN+1)

164

= [ a0b0 + (a0b1+a1b0)x + (a0b2+a1b1+a2b0)x2 + … … + (a0bN-1+a1bN-2+…+aN-2b1+aN-1b0)xN-1 + (a1bN-1+a2bN-2+…+aN-2b2+aN-1b1)xN + (a2bN-1+…+aN-2b3+aN-1b2)xN+1 + … … + (aN-2bN-1+aN-1bN-2)x2N-3 + (aN-1bN-1)x2N-2 ] mod (xN+1) = (a0b0+a1bN-1+a2bN-2+…+aN-2b2+aN-1b1) + (a0b1+a1b0+a2bN-1+…+aN-2b3+aN-1b2)x + (a0b2+a1b1+…+aN-1b3)x2 ... + (a0bN-1+a1bN-2+…+aN-2b1+aN-1b0)xN-1 Note que el coeficiente de xj es: (a0bj+a1bj-1+…+ajb0+aj+1bN-1+…+aN-2bj+2+aN-1bj+1) Como en el caso del ejemplo pequeño, los coeficientes de este polinomio son los mismos que los valores de los productos internos a arriba. Es decir: a(x)×b(x) = 0 si y sólo si i a º roti(b’) = 0. Exactamente lo mismo sucede si hacemos las rotaciones sobre a en vez de sobre b’. Sea a(x)=g(x). Sea b(x)=h(x)=(xN+1)/g(x). Como g(x)·h(x) = (xN+1), es evidente (para x:=1/x) que: g(1/x)·h(1/x) = ((1/x)N+1). Luego, multiplicando ambos lados por xN: xN·g(1/x)·h(1/x) = xN·((1/x)N+1). N k r r k Como x = x ·x = x ·x , operando en ambos lados: xr·g(1/x)·xk·h(1/x) = (xN+1). Es decir, xk·h(1/x)=hR(x) divide a (xN+1). Sea h(x) = h0x0 + h1x1 + ... + hk-1xk-1 + hkxk. Luego hR(x) = hk + hk-1x + ... + h1xk-1 + h0xk. Como gr(h(x))=k, es claro que gr(hR(x))=k. Los resultados 9 y 8 de antes, prueban que hR(x) es el polinomio generador de un ideal isomorfo a un código cíclico, llamémosle Z, de dimensión r = N-k, cuya matriz generadora Hr × N es: hk hk -1 ... h0 0 0 ... 0   0 hk hk -1 ... h0 0 ... 0    HR =  ... ... ... ... ... ... ... ...  Es claro que: v  Z si y sólo si v=[b1 … br]·HR   0 hk hk -1 ... h0 0   0 ...  0 ... 0 0 hk ... h1 h0  Esto prueba también que las N-k filas de la matriz HR forman un conjunto linealmente independiente. Probaremos ahora que HR genera C┴. Recordemos que la matriz generadora G del código C es: g0 g1 ... gr 0 0 ... 0   0 g0 g1 ... gr 0 ... 0    G =  ... ... ... ... ... ... ... ... Es claro que: w  C si y sólo si w=[a1 … ak]·G.    0 ... 0 g0 g1 ... gr 0   0 ... 0 0 g0 ... gr -1 gr  Sabemos que v  C┴ si y sólo si wºv=0 Sabemos también que g(x)×h(x) = 0.

(con w  C, por definición).

El resultado previo afirma que la palabra g=g0g1...gN-1 (en la que los últimos símbolos posiblemente sean ceros) es ortogonal a la palabra b’=hR=hN-1...h1h0 y a todas sus rotaciones.

165

Sucede exactamente lo mismo al revés, es decir, la palabra hR es ortogonal a la palabra g y a todas sus rotaciones. Luego, como las palabras de C son combinaciones lineales de la palabra g y sus rotaciones. Y como las palabras de Z=gen(HR) son combinaciones lineales de la palabra hR y sus rotaciones. Y como en el Anexo 3 probamos que: (a∙u  b∙v)ºw = a∙(uºw) + b(vºw). Se deduce que todas las palabras de C son ortogonales a todas las palabras de Z, en particular todas las palabras de C son ortogonales a hR y a todas sus rotaciones (ZC┴). Las filas de HR forman un conjunto linealmente independiente de N-k elementos en C┴ (por la ortogonalidad y la definición de código dual). Al ser N-k la dimensión de C┴ (ver el anterior capítulo) una de sus bases es este conjunto. Entonces Z = C┴. Es decir, el código generado por HR es C┴ (el dual de C). (Nótese que HR es la matriz de paridad de C). Dado el isomorfimo entre ideales y códigos, C┴ es isomorfo a un ideal, llamémosle Cp┴. El resultado sigue.

Recordemos que un código lineal C se dice sistemático (o está en forma canónica) si su matriz generadora G está en forma canónica. Es decir: Gk × N = [ Ik × k : Ak × N-k ] Se denomina así porque al construir las palabras código w=[a1 … ak]·G, el mensaje original a1…ak aparece íntegro a la izquierda y luego los símbolos de testeo (bits de paridad). Otra posibilidad igualmente válida, que indicamos ahora, es que: Gk × N = [ Ak × N-k : Ik × k ]. En este caso, al contruir las palabras código w=[a1 … ak]·G, el mensaje original a1…ak aparece íntegro al final con los símbolos de paridad al principio. Con esta versión de canonicidad, podemos hacer algunas analogías más con polinomios respecto de lo que puede hacerse con matrices y/o palabras código. Trabajando con polinomios en Cp

Trabajando con matrices en el código C Codificación sistemática. La matriz generadora (sistemática o canónica) Gc = [ A : I ], se obtiene a partir de G mediante operaciones elementales de filas y columnas.

Codificación sistemática. Dado v(x), se obtiene su polinomio sistemático así: w(x) = [v(x)·xr mod g(x)] + v(x)·xr

Así la información aparece íntegra al final y Así la información aparece íntegra al final y la redundancia al principio. la redundancia al principio.

Supondremos que se trabaja con códigos sistemáticos. El síndrome de la cadena w es: s = w·HT

Supondremos que se trabaja con codificación sistemática. El síndrome de w(x) es: s(x) = w(x) mod g(x)

Esto es parte de la decodificación de w.

Esto es parte de la decodificación de w(x).

Demostraremos ahora los resultados que sustentan la última tabla.

166

Si g(x) es el polinomio generador de Cp y v(x) es un polinomio con gr(v(x))=k-1 Entonces su codificación sistemática es w(x) = [v(x)·xr mod g(x)] + v(x)·xr. Demostración: Supondremos k bits de mensaje y r bits de redundancia. Debido al requerimiento de sistematicidad, ya no es posible codificar v(x) así: v(x)·g(x) = w(x) En su lugar, la codificación debe incluir otro polinomio q(x) [en función de v(x)] tal que: w(x) = q(x)·g(x) = d(x) + v(x)·xr Es claro que es posible asignar q(x)=[d(x) + v(x)·xr]/g(x). Es evidente que estamos pensando que los coeficientes del polinomio d(x), constituyan la redundancia, y que su grado sea a lo más r-1. Es claro también, para que la información aparezca íntegra a la derecha (luego de la redundancia), que v(x) debe “trasladarse” al final de w(x), cuyo grado es a lo más (N-1), y como gr(v(x)) es a lo más k-1, tal “traslado” sucede multiplicando v(x) por xr. Resta determinar d(x). Como w(x) = d(x) + v(x)·xr, entonces: w(x) + v(x)·xr = d(x) (1) Recordemos también que w(x) = q(x)·g(x), es decir w(x) mod g(x) = 0 Operando módulo g(x) a cada lado de (1): v(x)·xr mod g(x) = d(x) mod g(x) Pero, d(x) mod g(x) = d(x), pues gr(d(x))r-1 y gr(g(x))=r. Luego: d(x) = v(x)·xr mod g(x) Resumiendo, la codificación sistemática de v(x), es decir, su polinomio sistemático es: w(x) = [v(x)·xr mod g(x)] + v(x)·xr

Sea g(x) el polinomio generador de Cp. Si w(x)Z2N[x]/(xN+1) Entonces su síndrome es s(x) = w(x) mod g(x) Demostración: Recordemos que hay un isomorfismo entre C y Cp. Una forma de construir la matriz generadora canónica G del código C, a partir del polinomio g(x), se desprende del siguiente resultado previo. Si g(x) -de grado r- es el polinomio generador de Cp (un subespacio de dimensión k) Entonces { xr+i + Ai(x) / 0  i  k-1 } es una base de Cp. donde Ai(x) = xr+i mod g(x) 0  i  k-1; gr(Ai(x))
167

Del resultado previo y del isomorfismo entre C y Cp, se deriva que una matriz generadora de C es la que tiene por filas los coeficientes de los polinomios {Ai(x) + xr+i / 0  i  k-1}. Sea Ai(x) = ai0 + ai1x + ... + ai(r-1)xr-1, luego: [ a00 a01 [ a10 a11 G= [ [ a(k-1)0 a(k-1)1

... a0(r-1) 1 0 ... 0 ] ... a1(r-1) 0 1 ... 0 ] ... ] ... a(k-1)(r-1) 0 ... 0 1 ]

[ A0(x) + xr ] [ ] ...  [ ] r+k-1 [ Ak-1(x) + x ]

Esta matriz generadora es de la forma canónica Gk × N=[Ak × N-k : Ik × k]. Sabemos que su matriz de paridad es H=[I(N- k) × (N- k) : AT]. Es decir: [ 1 0 ... 0 a00 a10 ... a(k-1)0 ] [ 0 1 ... 0 a01 a11 ... a(k-1)1 ] H= [ ... ] [ 0 ... 0 1 a0(r-1) a1(r-1) ... a(k-1) (r-1) ] El síndrome de la palabra w=w1...wN se calcula así: s = w·HT. Es decir: [ 1 0 ... 0 ] [ 0 1 0 ... 0 ] [ ... ] s = [w1 w2 ... wN] · [ 0 ... 0 1 ] [ a00 a01 ... a0(r-1) ] [ a10 a11 ... a1(r-1) ] [ ... ] [ a(k-1)0 a(k-1)1 ... a(k-1)(r-1) ] Efectuando el producto, que por razones de espacio será representado por una matriz transpuesta de (N- k)×1: [ w1 + wN-k+1 a00 + wN-k+2 a10 + … + wN a(k-1)0 ]T [ w2 + wN-k+1 a01 + wN-k+2 a11 + … + wN a(k-1)1 ] s= [ ... ] [ wN-k + wN-k+1 a0(r-1) + wN-k+2 a1(r-1) + … + wN a(k-1)(r-1) ] La representación polinómica de s es: s(x) = w1 + wN-k+1 a00 + wN-k+2 a10 + … + wN a(k-1)0 + w2 x + wN-k+1 a01 x + wN-k+2 a11 x + … + wN a(k-1)1 x ... + wN-k xr-1 + wN-k+1 a0(r-1) xr-1 + wN-k+2 a1(r-1) xr-1 +…+ wN a(k-1)(r-1) xr-1 Al observar s(x) atentamente (“por columnas”, en la forma que lo hemos escrito) y tomando en cuenta que Ai(x) + xr+i = qi(x)·g(x), es decir Ai(x) = xr+i + qi(x)·g(x), se ve que: s(x) = w1+ w2 x + … + wN-k xr-1 + wN-k+1 A0(x) + wN-k+2 A1(x) + … + wN Ak-1(x) = w1+ w2 x + … + wN-k xr + wN-k+1 [xr + q0(x)·g(x)] + wN-k+2 [xr+1 + q1(x)·g(x)] + … + wN [xr+k-1 + qk-1(x)·g(x)] = w1+ w2 x + … + wN-k xr-1 + wN-k+1 xr + wN-k+2 xr+1 + … + wN xr+k-1 + wN-k+1 q0(x)·g(x) + wN-k+2 q1(x)·g(x) + … + wN qk-1(x)·g(x) = w(x) + [wN-k+1 q0(x) + wN-k+2 q1(x) + … + wN qk-1(x)]·g(x) Es decir:

168

w(x) = [wN-k+1 q0(x) + wN-k+2 q1(x) + … + wN qk-1(x)] · g(x) + s(x) = Q(x) · g(x) + s(x) Nótese que como s(x)=w1+ w2 x +…+wN-k xr-1 + wN-k+1 A0(x) + wN-k+2 A1(x)+…+wN Ak-1(x) y como gr(Ai(x))
Ejemplos: Sea C = { 000, 101, 011, 110 }  {0} el código cíclico de longitud N=3 visto antes. Sea Cp = { 0, 1 + x2, x + x2, 1 + x } el ideal asociado a C. 1) g(x) = (1 + x) es el único polinomio de grado mínimo r = 1  0 en Cp. 2), 3) y 4) Nótese que para: b(x) = 0: [b(x) · (1 + x)] = 0. b(x) = 1: [b(x) · (1 + x)] = (1 + x). b(x) = x: [b(x) · (1 + x)] = (x + x2). b(x) = 1+x: [b(x) · (1 + x)] = (1 + x2). Luego, Cp  { b(x) · (1 + x) / gr(b(x)) < (N−r)=2 }. { b(x) · (1 + x) / gr(b(x)) < 2 }  Cp. Cp = { b(x) · (1 + x) / gr(b(x)) < 2 }. Es decir, (1 + x) genera Cp. 5) (1 + x) | (x3 + 1). En efecto: (x3 + 1) = (1 + x) · (1 + x + x2) = (1 + x + x2) + (x + x2 + x3) 6) Como N = 3 y r = 1, es claro que k = 2. { g(x), x ×g(x), ... , xk-1 × g(x) } = { 1 + x, x × (1 + x) } = { 1 + x, x + x2 } Dicho conjunto es linealmente independiente, pues la ecuación: a0 (1 + x) + a1 (x + x2) = 0 Para a0=0, a1=1 es: (x + x2)  0 Para a0=1, a1=0 es: (1 + x)  0 Para a0=1, a1=1 es: (1 + x) + (x + x2) = (1 + x2)  0 Recordemos que a0,a1{0,1}. Luego, la única solución es para a0=a1=0. La demostración páginas atrás es más interesante pues señala en general lo que aquí en el ejemplo es evidente: Que gr([a0 (1 + x) + a1 (x + x2)]) < N=3. De manera que el único modo en que [a0 (1 + x) + a1 (x + x2)] mod (x3 + 1) = 0 es para 0 i 1: ai = 0. Además, { 1 + x, x + x2 } genera Cp. En efecto: 0 = 0.(1 + x) + 0.(x + x2) 1 + x2 = 1.(1 + x) + 1.(x + x2) x + x2 = 0.(1 + x) + 1.(x + x2) 1 + x = 1.(1 + x) + 0.(x + x2) Luego, { 1 + x, x + x2 } es una base de Cp. 7) Es obvio en nuestro ejemplo que la dimension de Cp es k=2 (una de sus bases tiene 2 elementos). 8) La matriz generadora de C se puede escribir así: 1 1 0 G =  Esta matriz genera C. En efecto: 0 1 1 

169

1 1 0 [0 1] ·  = [(0.1+1.0) (0.1+1.1) (0.0+1.1)] = [0 1 1]  0 1 1  1 1 0 [1 0] ·  = [(1.1+0.0) (1.1+0.1) (1.0+0.1)] = [1 1 0]  0 1 1  1 1 0 [1 1] ·  = [(1.1+1.0) (1.1+1.1) (1.0+1.1)] = [1 0 1]  0 1 1  [0 0] · G = [0 0 0] La dimensión de C es el número de pivotes de la forma escalonada de G: dim(C) = 2. 9) Como g(x) = (1 + x) es un factor de (x3 + 1), ya vimos que es el polinomio generador del ideal Cp = { 0, 1 + x2, x + x2, 1 + x }. Cuyo código cíclico asociado es C = { 000, 101, 011, 110 }. Y efectivamente g(x) es el polinomio generador de un código cíclico C. 10) También ya vimos que para el ideal { 0, 1 + x2, x + x2, 1 + x } se obtiene su polinomio generador g(x) eligiendo el polinomio de menor grado ( 0), en este caso g(x) = 1 + x. 11) El polinomio de paridad de g(x) = (1 + x), se obtiene así: h(x) = (xN + 1) / g(x) = (x3 + 1) / (1 + x) = (1 + x + x2) h(x) trabaja como polinomio de paridad en el siguiente sentido: w(x) × h(x) = 0 si y sólo si w(x)Cp. En efecto: Para wC, digamos 011: w(x) × h(x) = (x + x2) × (1 + x + x2) = (x + x2) · (1 + x + x2) mod (x3 + 1) = (x + x4) mod (x3 + 1) = 0 Para wC, digamos 100: w(x) × h(x) = ( 1 ) × (1 + x + x2) = ( 1 ) · (1 + x + x2) mod (x3 + 1) = (1 + x + x2) mod (x3 + 1) = (1 + x + x2) El comportamiento es análogo para las otras palabras que estén en C y para las otras Palabras que no estén en C. 12) El ideal dual Cp┴ se obtiene a partir de: hR(x) = xk · h(1/x) = x2 · (1 + 1/x + 1/x2) = (x2 + x + 1) = (1 + x + x2) = h(x) El código dual C┴, asociado al ideal Cp┴, tiene por matriz generadora: HR = [1 1 1] De donde C┴ = { 000, 111 } Que ciertamente es lineal y cíclico y tiene todas sus palabras ortogonales a las de C. Nótese que esto no siempre sucede y en general el código C‟ asociado al ideal generado por h(x) es lineal y cíclico, pero no es el dual de C. Constatamos ello en este otro ejemplo: (x7 + 1) = (1 + x2 + x3 + x4) · (1 + x2 + x3) = g(x) · h(x) Luego g(x) genera Cp. Es claro que (1 + x2 + x3 + x4)Cp. También es claro que su palabra código asociada 1011100C. Si tomamos a h(x) como el polinomio generador de un ideal C‟p. Es claro que (1 + x2 + x3)C‟p. También es claro que su palabra código asociada 1011000C‟. Pero (1011100) º (1011000) = 1  0. Luego C‟ no es el dual de C. Puede verificarse sin embargo que hR(x) = x3 · h(1/x) = (1 + x + x3) genera el ideal Cp┴ cuyo código asociado C┴ es el dual de C. De hecho la multiplicación G·HRT (donde las matrices G y HR se obtienen de g(x) y hR(x) como se indicó) nos da:

170

T

1 1 0 1 0 0 0 1 0 1 1 1 0 0   0 0 0 0  0 1 1 0 1 0 0  T   = 0 0 0 0  G·HR = 0 1 0 1 1 1 0 ·   0 0 1 1 0 1 0   0 0 1 0 1 1 1   0 0 0 0 0 0 0 1 1 0 1  13) Ya vimos en el inciso 4) como generar Cp={0, 1 + x2, x + x2, 1 + x}a partir de (1 + x). Nótese en tal inciso cómo se codifican cada uno de los polinomios b(x). Y de manera isomorfa cómo se codifican sus palabras asociadas. Por ejemplo: a(x) = b(x) = 1+x se codifica así: (1 + x2). Por asociación, la palabra: 11 se codifica así: 101 14) Dado v(x) = b(x) = 1+x, se obtiene su polinomio sistemático así: w(x) = [v(x)·xr mod g(x)] + v(x)·xr = [(1+x)·x mod (1+x)] + (1+x)·x = [(x+x2) mod (1+x)] + (x+x2) = [ 0 ] + (x+x2) = (x+x2) Por asociación, la codificación sistemática de la palabra 11 es: 011 Así la información aparece íntegra al final y la redundancia al principio. Una presentación muy popular de esta codificación sistemática, que obtiene exactamente lo mismo, es como sigue. - Obtener la palabra, de longitud k, asociada a v(x). Escribirla en reversa. Añadirle r ceros a la derecha. (a) - Obtener la palabra , de longitud r+1, correspondiente a g(x). Escribirla en reversa (b) - Dividir (a) entre (b) -división en aritmética módulo 2-. Obtener el residuo. Como sólo interesa el residuo, esta división puede hacerse haciendo XOR de izquierda a derecha entre (a) y (b) –desplazando (b)-. - La codificación se obtiene escribiendo este residuo, de longitud r, en reversa y agregando a su derecha la palabra asociada a v(x). En el ejemplo: Residuo de 110  11 en aritmética módulo 2: 110 XOR 11 000 equivalente a 0 Luego la codificación es: 011. 15) Suponiendo que trabajamos con codificación sistemática. La decodificación de w(x) pasa por calcular su síndrome así: s(x) = w(x) mod g(x). Por ejemplo para w(x) = (x+x2), su síndrome es s(x) = (x+x2) mod (1+x) = 0. Se puede hacer algo parecido al inciso 14 para obtener el síndrome apelando a la división binaria.

Hay familias específicas de códigos cíclicos, así como otros de diseño más reciente, que reciben su propio nombre: de Reed-Muller, de Bose-Chaudhuri-Hocquenghem (BCH), códigos de Reed-Solomon, de corrección por ráfagas, convolucionales, de redundancia cíclica (CRC), turbo códigos y un cada vez menos corto etcétera. Todos ellos son materia de otros capítulos que el lector puede buscar en textos que no sean introductorios como este que acaba.

171

ANEXO 1 lim pi · logr (1/pi ) = 0

pi  0

Demostración: ¿ Qué sucede con el límite lim x · ln(1/x ) ? x  0

lim x · ln(1/x ) = lim ( [ln(1/x )/1] x  0 x  0

/

[1/x ] )

obvio indeterminacion del tipo / puede aplicarse L'Hopital

= lim ( [ln(1/x )/1]' / [1/x ]' ) x  0 = lim ( [x · (- 1/x2) / 1] / [ - 1/x2] ) x  0

derivando (+ regla de la cadena)

= lim ( [- 1/x] / [ - 1/x2] ) x  0

obvio

= lim ( x ) x  0

obvio

=0 Así pues,

lim pi · logr (1/pi ) = [1/ ln(r)] · [ lim pi · ln(1/pi ) ]

pi  0

pi   0

pues logr z = (loge z / loge r)

= [1/ ln(r)] · [ 0 ]

por el anterior resultado

=0

obvio

172

ANEXO 2 Sea l>0 Si x>0

Kx  x·l

Entonces K  1

Demostración: Supongamos que K>1 Es claro que x>0 Sabemos que

Kx > 0 l>0

Luego, como x>0 Kx  x·l x>0 (1 / l)  (x / Kx)

resulta

Sea f(x) = 1/ l Sea g(x) = x / Kx Como las funciones f(x) y g(x) son tales que x>0 f(x)  g(x) es cierto. Tal desigualdad también se debe cumplir en el límite. Es decir: lim f(x)  lim g(x) x   x   Esto es, lim 1/ l  lim x / Kx x   x   El primer límite es obvio y el segundo se puede resolver por L'Hopital, de donde: 1/ l  lim 1 / ln(k)·Kx (recuerde que nuestro supuesto es que K>1) es decir, x   1/ l  0 Por otro lado, si l>0 es obvio que 1/ l> 0 1/ l  0 & 1/ l> 0 Esta contradicción, prueba el enunciado

173

ANEXO 3 Campos (Fields) y Espacios lineales (espacios vectoriales) Se llama grupo al par (G, +) donde G es un conjunto +:GXGG es una ley de composición interna sobre G, asociativa, con neutro e inverso El orden de un grupo es el número de elementos de G. Para cada entero p hay un grupo denominado el grupo cíclico de orden p, donde: G = Zp = { 0, 1, …, (p-1) } y la operación + es la suma módulo p: i + j = (i + j ) mod p Ejemplos: El siguiente es un grupo cíclico de orden 2. G = Z2 = { 0, 1 } + es la suma módulo 2: 0+0=0 0+1=1 1+0=1 1+1=0 El neutro es 0. El inverso de 0 es 0. El inverso de 1 es 1. Representaremos { 0, 1 }N por 2N. Sea G = V = 2N con N=3, es decir, V = 23 = { (0,0,0), (0,0,1), (0,1,0), (0,1,1), (1,0,0), (1,0,1), (1,1,0), (1,1,1) }  es la suma ordinaria de vectores, es decir, si w=(w1, w2, w3) y v=(v1, v2, v3), definimos w  v = (w1, w2, w3)  (v1, v2, v3) = (w1+v1, w2+v2, w3+v3) con + representando la suma módulo 2 Es claro que  es asociativa: w  v  u = w  (v  u) = (w  v)  u con neutro 0=(0,0,0) e inverso: el inverso de w=(w1, w2, w3) es w‟=( w1‟, w2‟, w3‟) con wj‟ el inverso de wj El par (V,  ) es un grupo de orden 8.

Se llama grupo abeliano a un grupo conmutativo, es decir, a un grupo donde la operación + es conmutativa. Ejemplo: El grupo (V,  ) de arriba es un grupo abeliano pues la suma de vectores es conmutativa.

Se llama anillo (ring) a una tripleta (R, +, ×) donde (R, +) es un grupo abeliano ×:RXRR es una ley de composición interna sobre R, asociativa × es distributiva sobre +: a × (b + c) = (a × b) + (a × c) 174

Es usual denominar adición y multiplicación a las operaciones + y × Se llama anillo conmutativo a un anillo donde la operación × es conmutativa. Se llama anillo con unidad a un anillo donde la operación × tiene neutro. Se llama anillo con división a un anillo con unidad donde cada elemento distinto del neutro 0 tiene inverso multiplicativo. Se llama campo (field) a un anillo con división conmutativo en el cual 0≠1. Es decir, a un tripleta (F, +, ×) donde (F, +) es un grupo abeliano (F, ×) es un grupo abeliano (el inverso es para los elementos distintos de 0) × es distributiva sobre +: a × (b + c) = (a × b) + (a × c) 0≠1 Se llama campo finito a un campo en el que el conjunto F es finito . Junto a otras consideraciones que no enfatizaremos los campos finitos que actúen sobre los enteros módulo p se denominan campos de Galois y se denotan como Zp , Fp o GF(p). Ejemplo: Con F = Z2 = { 0, 1 } La operación + como la suma módulo 2. × la multiplicación módulo 2: 0×0=0 0×1=0 1×0=0 1×1=1 Con neutro 1 y donde el inverso de 1 es 1. Resulta que (Z2, +, ×) es un campo, conocido como campo binario, campo Z2, F2 o GF(2). Se llama espacio lineal sobre el campo (F, +, ×) a la sextupla (V, F,  , +, ×, •) donde (V,  ) es un grupo abeliano (F, +, ×) es un campo •:FXVV es una función que satisface las siguientes condiciones 1) a•(b•w) = (a×b)•w a,b  F; w  V 2 (a+b)•w = a•w  b•w a,b  F; w  V 3) b•(w  u) = b•w  b•u b  F; u,w  V 4) 1•w = w w  V; 1 es el neutro (multiplicativo) de × Dado que muchos espacios lineales son espacios geométricos de vectores, usualmente un nombre alternativo al de espacio lineal es el de espacio vectorial; de manera que se habla de vectores (V), suma de vectores (  ), escalares (F) y multiplicación por escalares (•). V debe ser no vacío pero puede ser finito, en cuyo caso se tiene un espacio lineal finito.

175

Ejemplos: Son conocidos los espacios euclidianos o n-dimensionales con las operaciones comunes de adición y producto (en el conjunto de los reales R); junto a la suma de vectores y multiplicación por escalares (en el conjunto de las n-tuplas reales Rn). Utilizaremos recurrentemente el siguiente espacio lineal definido sobre el campo binario. (V, F,  , +, ×, •) V = 2N = { (0, …,0), …, (1, … ,1) } (donde el número de N-tuplas es 2N) F = { 0, 1 }  es la suma de vectores (módulo 2). +, × son la suma y multiplicación módulo 2. La multiplicación por escalares se define así: 0•w = (0, …, 0) y 1•w = w Se llama subespacio lineal sobre el campo (F, +, ×) a la sextupla (S, F,  , +, ×, •) donde (V, F,  , +, ×, •) es un espacio lineal SV es aun una ley de composición interna sobre S, es decir,  (w  u)  S para u,w  S (b•w)  S para w  S y b  F

Es común mencionar a un (sub)espacio lineal indicando sólo los conjuntos V(ó S) y F. Las siguientes definiciones se aplican tanto a espacios lineales como a subespacios lineales. Se llama combinación lineal finita a la suma v = a1•v1  …  ak•vk V es un (sub)espacio lineal sobre F k es un entero positivo ai  F vi  V De las definiciones para • y  es claro que v  V.

donde

Un subconjunto W de un (sub)espacio lineal V sobre F, se llama linealmente independiente cuando para cualquier conjunto {u1, …, um }  W la ecuación a1•u1  …  am•um = (0, …, 0) tiene como única solución la solución trivial, es decir: ai=0. Un conjunto que no es linealmente independiente se llama linealmente dependiente. Se llama espacio generado o envolvente lineal (o span set) de W  V (V es un (sub)espacio lineal sobre F) al conjunto de todas las combinaciones lineales finitas de los elementos de W. Se denota por gen(W). Se llama base de un (sub)espacio lineal V sobre F, a un subconjunto de V, llamado B, linealmente independiente, cuyo envolvente lineal es V. La base de un (sub)espacio lineal V sobre F no es necesariamente única.

176

Se llama dimensión de un (sub)espacio lineal V sobre F al número de elementos de cualquier base de V, se denota por dim(V). Cualquier texto de Álgebra Lineal muestra que si le añadimos otro elemento a una base B de V el conjunto resultante se torna linealmente dependiente, es decir, todas las bases de V tienen el mismo número de elementos.

Ejemplos: Presentaremos un caso concreto del espacio lineal finito ya visto (V, F,  , +, ×, •) V = 23 = { (0,0,0), (0,0,1), (0,1,0), (0,1,1), (1,0,0), (1,0,1), (1,1,0), (1,1,1) } F = { 0, 1 } Las operaciones  , +, ×, • son como antes. Una combinación lineal posible es: (0,1,0) = 1•(0,0,0)  1•(0,1,0)  0•(1,1,1) Sea W = { (0,0,1), (1,1,0), (1,1,1) }. Es claro que W  V La ecuación a1•(0,0,1) = (0,0,0) tiene única solución con a1=0 La ecuación a1•(0,0,1)  a2•(1,1,0) = (0,0,0) tiene única solución con a1=0, a2=0 Pero la ecuación a1•(0,0,1)  a2•(1,1,0)  a3•(1,1,1) = (0,0,0) tiene solución con a1=1, a2=1, a3=1. En efecto, 1•(0,0,1)  1•(1,1,0)  1•(1,1,1) = (0,0,1)  (1,1,0)  (1,1,1) = (0+1+1, 0+1+1, 1+0+1) = (0,0,0) Luego W es linealmente dependiente. Sea W = { (0,0,1) } La ecuación a1•(0,0,1) = (0,0,0) tiene única solución con a1=0 El envolvente lineal de W es: gen(W) = { (0,0,0), (0,0,1) } pues las únicas combinaciones lineales son del tipo a1•(0,0,1); más concretamente 0•(0,0,1) y 1•(0,0,1). Sea B = { (0,0,1), (0,1,0), (1,0,0) }. Es claro que B  V Si añadimos a B el elemento (1,1,1) el conjunto resultante es linealmente dependiente, pues la ecuación a1•(0,0,1)  a2•(0,1,0)  a3•(1,0,0)  a4•(1,1,1) = (0,0,0) tiene (también) la solución a1=1, a2=1, a3=1, a4=1. Dejaremos al lector comprobar que B es linealmente independiente y que gen(B)=23, es decir, B es base de dicho espacio lineal (que tiene así dimensión 3). Sea S = { (0,0,1) }. Es claro que S  V. Obviamente (0,0,1)  (0,0,1) = (0,0,0). Nótese que (0,0,1)  S, pero (0,0,0)  S , luego S no puede ser un subespacio lineal de V=23 sobre el campo binario. Sea S = { (0,0,0), (1,0,1), (0,1,1), (1,1,0) }. Es claro que S  V. Es fácil comprobar que S es cerrado respecto de la operación  . Además se cumple que (b•w)  S, pues con b=0 se obtiene (0,0,0) y con b=1 se obtiene el mismo elemento w  S. Luego S es un subespacio lineal de V=23 sobre el campo binario. Sea B = { (1,0,1), (0,1,1) }. Es claro que B  S

177

Es fácil comprobar que gen(B)=S. Dejaremos al lector comprobar que B es linealmente independiente. Es decir, B es la base del subespacio lineal S (que tiene así dimensión 2). Será útil representar los elementos de una base como filas de una matriz. 1 0 1 En el último ejemplo B =   0 1 1

Sea S un (sub)espacio lineal finito Entonces gen(S)=S. Demostración: Sea v  gen(S), es decir, v=a1•v1  …  ak•vk (vi  S, aj  F, k>0). Dado que S es un (sub)espacio lineal, es claro que ai•vi  S. Si asociamos de a dos los operandos de  , es claro también que (ai•vi  aj•vj)  S. Si seguimos asociando recurrentemente de a dos se deduce que v  S. Inversamente si v  S, es evidente que v  gen(S) con a1=1, v1=v y k=1. Al igual que una base B, podemos representar los elementos de un (sub)espacio lineal finito S como filas de una matriz. Ejemplo: 0 0 0  1 0 1  S = 0 1 1    1 1 0

Sean {u1, ... ,um} las filas de una matriz A (pueden ser los elementos de una base -del espacio lineal 2N o de algún subespacio de él-, o todos los elementos de algún (sub)espacio lineal –no solo los de la base-, pero pueden ser también cualesquier otros elementos, estamos pensando en elementos de 2N). Sean {c1, ... ,cN} las columnas de una matriz A. Se llama espacio de las filas de A al conjunto gen({u1, ... ,um}), denotado por RA. Se llama espacio de las columnas de A al conjunto gen({c1, ... ,cN}), denotado por CA. En particular, cuando las filas de la matriz A son los elementos de una base B de un (sub)espacio lineal, es obvio que RA es un (sub)espacio lineal. Dado que gen(S)=S cuando S es un (sub)espacio lineal finito, lo mismo sucede si las filas de la matriz son los elementos de S, es decir, RA es un (sub)espacio lineal también. Sin embargo, de manera general puede mostrarse que RA y CA son subespacios lineales de 2N y 2M cuando A es de NxM. Lo haremos para CA: Como CA=gen({c1, ... ,cN}) con ci una columna de A. Basta mostrar que para v,u  CA entonces a•v  CA y v  u  CA. Lo primero es obvio pues a=1 o bien a=0. Para lo segundo:

178

Como v=a1•c1  …  aN•cN y u=b1•c1  …  bN•cN (algunos ai,bj pueden ser cero, por concepto de combinación lineal). Luego, v  u=(a1•c1  …  aN•cN)  (b1•c1  …  bN•cN) que por asociatividad y conmutatividad y la condición 2 en la definición de espacio lineal puede reescribirse como v  u=(a1+b1)•c1  …  (aN+bN)•cN, que por ser F un campo puede reescribirse como v  u=d1•c1  …  dN•cN, es claro entonces que v  u  CA. Operaciones elementales sobre filas.- Son la permutación de filas, la multiplicación de una fila por una constante diferente de cero y el reemplazo de la fila ui por ui  b•uj. En el espacio lineal sobre el campo binario que estamos viendo, se reducen a permutación de filas y el reemplazo de la fila ui por ui  uj, es decir sumar la fila j a la fila i. Se dice que las matrices A y D son equivalentes por filas si una se puede obtener de la otra mediante operaciones elementales sobre filas. Cualquier texto de Álgebra Lineal muestra que si A es equivalente a D entonces R A=RD. Además la dimensión de RA es el número de pivotes en su forma escalonada. O lo que es lo mismo, las filas diferentes de cero en la forma escalonada de la matriz A, constituyen una base para RA. Así pues, la determinación de la base de un (sub)espacio lineal finito S puede hacerse mediante el método de Gauss colocando los elementos de S como filas de una matriz y hallando su forma escalonada. Las filas diferentes de cero son la base buscada. Operaciones elementales sobre columnas.- Consideraremos la permutación de columnas. Analicemos (un)el (sub)espacio lineal sobre el campo binario, sea G la matriz que representa una base de dicho (sub)espacio lineal. Sea G‟ una matriz que se obtiene permutando las columnas i-ésima y j-ésima de G. Es decir:  u1  b11 ... b1i ... b1j ... b1N G =  ...  =  ... ... ... ... ... ... ...   uk  bk1 ... bki ... bkj ... bkN

b11 ... b1j ... b1i ... b1N G‟=  ... ... ... ... ... ... ...  bk1 ... bkj ... bki ... bkN Recordemos que gen(G) es todo el (sub)espacio lineal en consideración. Dado que a1•u1  …  ak•uk = a1•[b11 .. b1i .. b1j .. b1N]  …  ak•[bk1 .. bki .. bkj .. bkN] =[a1×b11 .. a1×b1i .. a1×b1j .. a1×b1N]  …  [ak×bk1 .. ak×bki .. ak×bkj .. ak×bkN] =[a1×b11 +...+ ak×bk1, …, a1×b1i +...+ ak×bki, …, a1×b1j +...+ ak×bkj, ..., a1×b1N +...+ ak×bkN] (hemos puesto comas y negrita para aportar claridad) Una combinación lineal finita de G puede representarse así: b11 ... b1i ... b1j ... b1N [a1 … ak]·G = [a1 … ak]·  ... ... ... ... ... ... ...  bk1 ... bki ... bkj ... bkN

179

Veamos cómo es una combinación lineal finita de G‟: b11 ... b1j ... b1i ... b1N [a1 … ak]·G‟ = [a1 … ak]·  ... ... ... ... ... ... ...  bk1 ... bkj ... bki ... bkN =[a1×b11 +...+ ak×bk1, …, a1×b1j+...+ ak×bkj, …, a1×b1i +...+ ak×bki, ..., a1×b1N +...+ ak×bkN] (hemos puesto comas y negrita para aportar claridad) Es decir, las elementos de gen(G‟) son el resultado de permutar los elementos de gen(G) en exactamente las mismas posiciones i-ésima y j-ésima. De este modo ambos espacios lineales [gen(G‟) y gen(G)] difieren sólo en el orden de sus elementos. Producto interno (o producto punto) y ortogonalidad.- Sean v,w  2N. Se define su producto interno así: º : 2N × 2N  F vºw = v1·w1 + ... + vN·wN donde v = v1...vN y w = w1...wN (en rigor debiera escribirse vi×wi pero nos tomaremos la licencia de escribir · en vez de ×) Diremos que las cadenas v,w son ortogonales cuando vºw = 0. Nótese que (por la conmutatividad del producto módulo 2): vºw = v1·w1 + ... + vN·wN = w1·v1 + ... + wN·vN = wºv Además, mostraremos que (a∙u  b∙v)ºw = a∙(uºw) + b(vºw): Sean u=u1...uN , v=v1...vN , w=w1...wN (a∙u  b∙v)ºw = (a∙[u1...uN]  b∙[v1...vN])ºw obvio = ( [a∙u1 ... a∙uN]  [b∙v1 ... b∙vN])ºw obvio = [a∙u1+b∙v1 ... a∙uN+b∙vN]ºw suma de vectores = [a∙u1+b∙v1 ... a∙uN+b∙vN]º[w1...wN] obvio = (a∙u1+b∙v1)∙w1 + ... + (a∙uN+b∙vN)∙wN producto interno = (a∙u1∙w1+b∙v1∙w1) + ... + (a∙uN∙wN+b∙vN∙wN) obvio = (a∙u1∙w1 + ... + a∙uN∙wN) + (b∙v1∙w1 + ... + b∙vN∙wN) conmutatividad y asociatividad = a∙(u1∙w1 + ... + uN∙wN) + b∙(v1∙w1 + ... + vN∙wN) obvio = a∙([u1 ...uN]º[w1...wN]) + b∙([v1 ...vN]º[w1...wN]) producto interno = a∙(uºw) + b∙(vºw) obvio Núcleo de una matriz.- Sea Gk × N la matriz generadora del subespacio lineal C. Se denomina núcleo (o kernel o espacio nulo) de G al conjunto: NG = { v  2N / G·v = 0 } donde 0 representa una columna de k ceros v debe estar como columna en el producto G·v NG es un subespacio lineal de 2N. En efecto, la multiplicación por un escalar no nulo b, en nuestro contexto, podemos reducirla al escalar b=1, de manera que si v  NG es inmediato que (b·v)  NG. Por otro lado sean u,v  NG, es decir, G·u = 0 y G·v = 0. Veamos qué sucede con w = u  v: G·w = G·(u  v) obvio = G·u  G·v ley distributiva para la multiplicación de matrices = 0  0 por hipótesis = 0 obvio Luego w  NG, lo que prueba el enunciado. (En rigor G puede ser cualquier matriz)

180

Imagen de una matriz.- Sea Gk × N la matriz generadora del subespacio lineal C. Se denomina imagen de G al conjunto: I G = { u  2k / G·v = u, v  2N } v debe estar como columna en el producto G·v (En rigor G puede ser cualquier matriz) Cualquier texto de Álgebra Lineal muestra que IG es un subespacio lineal de 2k, además de los siguientes resultados importantes: 1) (espacio de las columnas) CG = IG (imagen de G) 2) El subespacio lineal IG (la imagen de G) tiene dimensión k k recibe también el nombre de rango de G 3) dim(CG) = dim(RG) (dimensión del espacio de las columnas) = (dimensión del espacio de las filas) 4) k + dim(NG) = N donde N es el número de columnas de G De 4 se deduce la siguiente importante propiedad: 5) El subespacio lineal NG (el núcleo de G) tiene dimensión N-k, es decir, dim(NG) = N - k. Co-conjunto (en inglés coset).- Sea C un subespacio lineal de 2N. Sea u  2N. Llamaremos co-conjunto de C al siguiente conjunto: u+C = { u+w / w  C } Es claro que no siempre la secuencia de ceros pertenece al co-conjunto (-por ejemplo con uC-. Es decir para u+w en el co-conjunto no siempre b•(u+w)=0 -con b=0- está en el coconjunto). Luego, en general un co-conjunto no es un subespacio lineal. Tiene sin embargo propiedades interesantes. Sea C un subespacio lineal (finito) de 2N con dimensión k Entonces i) Si u+C es un co-conjunto de C Entonces u+C tiene 2k elementos ii) Si v  u+C Entonces v+C=u+C iii) Si u  2N Entonces u pertenece únicamente a un co-conjunto iv) Hay exactamente 2N-k co-conjuntos v) Los 2N-k co-conjuntos son disjuntos y cubren 2N Demostración: i) Es evidente que hay tantos elementos en u+C como elementos hay en C. Si C tiene dimensión k, es decir, k elementos en su base (digamos B={v1,…, vk}), cada elemento de C es una combinación lineal de su base: a1•v1  …  ak•vk con aj  F k Como aj puede ser cualquiera de 2 valores (0 o 1) es claro que hay 2 combinaciones posibles. Es decir, C tiene 2k elementos. El resultado sigue. ii) Sea v  u+C. Luego -por definición- v=u+w (w  C). (*) Entonces: v+C = { v+w' / w'  C } por definición = { u+w+w' / w'  C, w  C } por (*) = { u+w'' / w''  C } por ser C un subespacio lineal = u+C por definición En el penúltimo paso, como w,w'  C, es decir, tomamos todos los distintos pares de elementos en C, su suma w+w' abarca todo C. Ello es evidente tomando w'=0.

181

iii) Como C es un subespacio lineal, debe contener a la secuencia de ceros. Luego, u  u+C (tomando w=0). Supongamos que u  v+C (con v+Cu+C). Por definición de co-conjunto u=v+w' (w'  C). Luego, v=u+w'. Es decir, -por definición- v  u+C. Pero entonces -por ii- v+C=u+C. El resultado sigue. iv) Hay 2N elementos en 2N y –por iii- cada uno de ellos pertenece únicamente a un coconjunto. Dado que -por i- cada co-conjunto tiene 2k elementos, es evidente que deben haber: 2N/2k = 2N-k co-conjuntos. v) Es una simple consecuencia de iii y iv.

182

ANEXO 4 Sea b(x) = b1x0 + b2x1 + ... + bNxN-1 + bN+1xN

un polinomio de grado n.

Sea Z2[x] el conjunto de todos los polinomios (de cualquier grado) con coeficientes bi en GF(2) = Z2 = {0,1}. Es claro - por lo visto en el Anexo 3- que: El par (Z2[x], +) es un grupo abeliano. Donde + denota la suma -conmutativa- de polinomios, con neutro b(x) = 0 y debido al campo binario cada polinomio es su propio inverso. La tripleta (Z2[x], +, ×) es un anillo conmutativo con unidad. Donde × denota la multiplicación -conmutativa- de polinomios, con neutro b(x) = 1; y donde la multiplicación de polinomios es distributiva sobre la adición de polinomios: b(x)[c(x)+d(x)] = b(x)c(x) + b(x)d(x) Así pues (Z2[x], +, ×) es el anillo de todos los polinomios con coeficientes en Z2. Lamentablemente no sucede lo mismo si nuestro conjunto es de todos los polinomios con coeficientes en Z2 de grado N. En efecto, basta verificar que la multiplicación de dos polinomios de grado N, no es de grado N sino de grado 2N, quebrándose la ley de composición interna para la operación multiplicación de polinomios. Sin embargo, si denotamos por Z2N[x] al conjunto de todos los polinomios de grado menor a N (con coeficientes en Z2), entonces podemos definir una operación × (multiplicación de polinomios en el conjunto) que nos permita obtener un anillo. Tal operación se denomina multiplicación de polinomios módulo p(x) [donde p(x) es otro polinomio] y se define -genéricamente- así: Sean q(x), t(x), p(x) polinomios con coeficientes en el campo F. La multiplicación de los polinomios q(x) y t(x) módulo p(x) es el resto de dividir q(x)·t(x) entre p(x). Ejemplo: q(x) = x t(x) = 1 + x p(x) = x2 + 1 q(x) × t(x) = q(x)·t(x) mod p(x) = x·(1 + x) mod (x2 + 1) = x + x2 mod (x2 + 1) = 1 + x Es evidente que si p(x) = xN + 1, los resultados de la multiplicación de polinomios módulo p(x), son polinomios de grado menor a N, es decir, × es una ley de composición interna. Así pues, es evidente que el par (Z2N[x], +) es un grupo abeliano. Donde + denota la suma (evidentemente) conmutativa de polinomios, con neutro b(x) = 0 y, debido a que los coeficientes están en el campo binario, cada polinomio es su propio inverso. También la tripleta (Z2N[x], +, ×) es un anillo conmutativo con unidad. Donde × denota la multiplicación de polinomios módulo (xN + 1). En efecto, ya mostramos que × es una ley de composición interna.

183

La siguiente igualdad muestra que × es asociativa: p(x) × [q(x) × t(x)] = p(x) × [q(x) · t(x) mod (xN + 1)] por definición de × = p(x) · [q(x) · t(x) mod (xN + 1)] mod (xN + 1) por definición de × N N = p(x) · [q(x) · t(x) – k(x) · (x + 1)] mod (x + 1) k(x): cociente de q(x)·t(x)/(xN + 1) = [p(x) · q(x) · t(x) – p(x) · k(x) · (xN + 1)] mod (xN + 1) distribuyendo p(x) = p(x) · q(x) · t(x) mod (xN + 1) operando mod N N = [p(x) · q(x) · t(x) – k‟(x) · (x + 1) · t(x) ] mod (x + 1) k‟(x): cociente p(x)·q(x)/(xN + 1) = [p(x) · q(x) – k‟(x) · (xN + 1) ] · t(x) mod (xN + 1) factorizando t(x) N N = [p(x) · q(x) mod (x + 1) ] · t(x) mod (x + 1) definición de módulo = [p(x) · q(x) mod (xN + 1) ] × t(x) por definición de × = [p(x) × q(x)] × t(x) por definición de × Por otro lado: p(x) × [q(x) + t(x)] = p(x) · [q(x) + t(x)] mod (xN + 1) = [p(x) · q(x) + p(x) · t(x)] mod (xN + 1) = [p(x) · q(x) mod (xN + 1)] + [p(x) · t(x) mod (xN + 1)] = p(x) × q(x) + p(x) × t(x) Es decir, × es distributiva sobre +. Es claro que: q(x) × t(x) = q(x)·t(x) mod (xN + 1) = t(x)·q(x) mod (xN + 1) = t(x) × q(x), es decir, × es conmutativa. Sean b(x)=1,p(x)Z2N[x]: p(x) × b(x) = p(x) × 1 = p(x)·1 mod (xN + 1) = p(x) mod (xN + 1) = p(x) Es decir b(x) = 1 es el neutro para ×. Es usual denotar a dicho anillo como Z2N[x]/(xN+1). Por otro lado: - Se sabe que F2 es el campo binario ({0, 1}, +, ×), con la suma y multiplicación módulo 2 - Ya vimos que (Z2N[x],  ) es un grupo abeliano –donde se utiliza el símbolo  para la suma de polinomios- Definiendo así •:{0, 1} × Z2N[x]  Z2N[x] 0 • p(x) = 0 1 • p(x) = p(x) Es claro que (Z2N[x], {0, 1},  , +, ×, •) es un espacio lineal finito sobre F2. Cp  Z2N[x]/(xN+1) se denomina ideal cuando: (Cp,  ) es un subgrupo abeliano de (Z2N[x],  ) p(x)Cp q(x)Z2N[x]/(xN+1) p(x)×q(x)Cp Una forma conocida de construir un ideal, tomando un polinomio g(x)  0, es así: I = { g(x) × q(x) / q(x)Z2N[x]/(xN+1) } Que I sea un ideal es inmediato.

184

ÍNDICE alfabeto (del) código, 22 algoritmos de decodificación, 142 arreglo estándar, 142 Blahut-Arimoto, 102 bloque, 22 canal binario borrador, 87 canal binario simétrico (BSC), 86 canal débilmente simétrico, 86 canal simétrico, 86 canales ambiguos, 85 canales de información con ruido, 71 canales determinantes, 84 canales sin ruido, 83 cantidad de información, 6 Chapman-Kolmogorov, 14 co-conjunto, 142 codificación aritmética, 68 codificación sistemática, 166 código dual, 134 código equivalente, 133 código extendido o expandido, 141 código lineal, 130 código maximal, 120 código perfecto, 121 códigos (del) canal, 115 códigos cíclicos, 154 códigos de fano, 62 códigos de Hadamard, 127 códigos de Hamming, 125 códigos de Huffman, 63 códigos de paridad, 124 códigos de Shannon, 62 compacto, 54 cota de Singleton, 147 desigualdad del triángulo, 112 distribución estacionaria, 13 dual, 163 eficiencia, 59 entropía, 7 equivocación del canal, 73 estandarización de las entradas, 117

extensión de la Fuente-M, 19 extensión de orden n de una fuente de información de memoria nula, 9 forma canónica, 134 fuente afín o adjunta, 18 fuente de memoria nula, 6 fuente equiprobable, 6 fuente reducida, 64 fuente regular y ergódica, 15 Gibbs, 48 ideal, 155 información mutua, 73 instantáneo, 26 L(C), 54 libre de prefijos, 23 líder, 142 límite de Gilbert-Varshamov, 122 límite de Hamming, 119 longitud media de un código, 54 matriz de (testeo de) paridad, 135 matriz típica, 142 mellizas, 57 Nguyen Hung Vu, 34 no-singular, 22 patrón de error, 142 Patterson y Sardinas, 24 Perron-Frobenius, 14 peso de una palabra código, 132 polinomio generador, 158 principios de decodificación, 103 reducción elemental, 97 reducción suficiente, 98 redundancia, 59 shannon, 61, 107 síndrome, 140, 166 singular, 22 sistema de entropías, 73 tabla de síndromes, 145 unívocamente decodificable, 24 velocidad del código, 109

185

BIBLIOGRAFÍA

Togneri Roberto, deSilva Christopher "Fundamentals of Information Theory and coding Design" Editorial Chapman & Hall Primera Edición. Año 2002

Jones Gareth, Jones Mary "Information and Coding Theory" Editorial Springer Segunda impresión. Año 2002

Wells Richard "Applied Coding and Information Theory for Engineers" Editorial Prentice Hall Primera Edición. Año 1999

Abramson Norman "Information Theory and Coding" Traducción al español de Juan Antonio de Miguel Menoyo Editorial Paraninfo Primera Edición. 1986

186

TeoriadelaInformacionylaCodificacion

Recommend Documents