TeoriadelaInformacionylaCodificacion PDF

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 y a Marcio Gutierrez.
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
luciotorrico@gmail.com
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í: Ejemplo concreto de una Fuente-S:
S pi S pi
s1 p1 s1 0.2
. . s2 0.1
s3 0.35
. . s4 0.35
. .
sq pq 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 1/2
s2 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 cuando pi = 1, I(si) = logr 1/1 = logr 1 = 0 r-its

Por convención cuando pi = 0, I(si) = logr 1/0 = - logr 0 = +∞ r-its
Entropía de una fuente de información de memoria nula, denotada por Hr(S).- Está
definida por:
q q q
Hr(S) = ∑ pi · I(si) = ∑ pi · logr 1/pi = - ∑ pi · logr pi r-its
i =1 i =1 i =1
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:
S pi 4
He(S) = ∑ pi · loge 1/pi
s1 0.2 i =1
s2 0.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)
s3 0.35 = 2/10 · ln (10/2) + 1/10 · ln (10/1) + 35/100 · ln(100/35) + 35/100 · ln(100/35)
s4 0.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 r-its

i=1 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 pi
s1 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:
S pi
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 pj
σ1 = s 1 s 1 p1· p1 = 0.04
σ2 = s 1 s 2 p1· p2 = 0.16
σ3 = s 2 s 1 p2 · p1 = 0.16
σ4 = s 2 s 2 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/00)=0.2 p(1/00) = 0.8
p(0/01)=0.4 p(1/01) = 0.6
p(0/10) =0 p(1/10) = 1
p(0/11) =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):
00 01 10 11 Nótese que las columnas deben sumar 1.

00 0.2 0 0 0
P= 01 0.8 0 1 0
10 0 0.4 0 0.5
11 0 0.6 0 No es común etiquetar los nombres de los estados, de
0.5
manera que es más frecuente ver P así:
0.2 0 0 0
P= 0.8 0 1 0
0 0.4 0 0.5
0 0.6 0 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) r-its
i =1
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/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
Y en forma de matriz:
0.8 0 0.5 0
P= 0.2 0 0.5 0
0 0.5 0 0.2
0 0.5 0 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 bits

H2(S/α2) = H2(S/01) = 1 bits
H2(S/α3) = H2(S/10) = 1 bits
H2(S/α4) = H2(S/11) = 0.72192 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 ⎥ junto a w1 + w2 + w3 + w4 = 1
⎢ 0 0.5 0 0.2⎥ ⎢ w3 ⎥ ⎢ w3 ⎥
⎢ ⎥ ⎢ ⎥ ⎢ ⎥
⎣ 0 0.5 0 0.8⎦ ⎣ w4 ⎦ ⎣ w4 ⎦
Es decir,
0.8 w1 + 0.5 w3 = w1
0.2 w1 + 0.5 w3 = w2
0.5 w2 + 0.2 w4 = w3
0.5 w2 + 0.8 w4 = 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 bits
H2(S/α2) = H2(S/01) = 1 bits
H2(S/α3) = H2(S/10) = 1 bits
H2(S/α4) = H2(S/11) = 0.72192 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) .
t − >∞
Llamaremos distribución límite a cualquier columna de P(∞).
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 0⎤
⎢0.2 0 1 0 ⎥⎥
P= ⎢
⎢ 0 0.6 0 0.5⎥
⎢ ⎥
⎣ 0 0.4 0 0.5⎦
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 0 0⎤
⎢1 0 1 0 ⎥⎥
P= ⎢
⎢0 0.6 0 0.5⎥
⎢ ⎥
⎣0 0.4 0 0.5⎦
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.
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.
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) · w4
j =1
= 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 0.5
s2 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:
nμ
p(σi / σj1...σjμ ) (Es claro que existen q estados)
= 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) · ... (1)
... · p(si n / sj1n...sjμ1sjμ2...sjμnsi1si2...si (n-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<n)
Ejemplo: Sea la siguiente Fuente-M con S={s1, s2}={0,1} q=2 orden m=2
Los qm=4 estados son:

α1=s1s1=00
α2=s1s2=01
α3=s2s1=10
α4=s2s2=11
19
Listado de probabilidades:
p(0/00)=0.8 P(α1->α1)=0.8
p(1/00)=0.2 p(α1->α2)=0.2
p(0/01)=0.5 p(α2->α3)=0.5
p(1/01)=0.5 p(α2->α4)=0.5
p(0/10)=0.5 p(α3->α1)=0.5
p(1/10)=0.5 p(α3->α2)=0.5
p(0/11)=0.2
p(α4->α3)=0.2
p(1/11)=0.8
p(α4->α4)=0.8
Matriz de transiciones:
00 01 10 11
α1 α2 α3 α4
α1 0.8 0 0.5 0 P=
α2 0.2 0 0.5 0
α3 0 0.5 0 0.2
α4 0 0.5 0 0.8
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(β1->β1)=0.64
p(00/01)=p(0/01)·p(0/10)=0.5·0.5=0.25 p(β2->β1)=0.25
p(00/10)=p(0/10)·p(0/00)=0.5·0.8=0.4 p(β3->β1)=0.4
p(00/11)=p(0/11)·p(0/10)=0.2·0.5=0.1 p(β4->β1)=0.1
p(01/00)=0.16 p(β1->β2)=0.16
p(01/01)=0.25 p(β2->β2)=0.25
p(01/10)=0.1 p(β3->β2)=0.1
p(01/11)=0.1 p(β4->β2)=0.1
p(10/00)=0.1 p(β1->β3)=0.1
p(10/01)=0.1 p(β2->β3)=0.1
p(10/10)=0.25 p(β3->β3)=0.25
p(10/11)=0.16 p(β4->β3)=0.16
p(11/00)=0.1 p(β1->β4)=0.1
p(11/01)=0.4 p(β2->β4)=0.4
p(11/10)=0.25 p(β3->β4)=0.25
p(11/11)=0.64 p(β4->β4)=0.64
Matriz de transición entre estados (de la fuente extendida):
00 01 10 11
s1 s1 s1 s2 s2 s1 s2 s2
σ1 σ2 σ3 σ4
β1 β2 β3 β4
β1 0.6400 0.2500 0.4000 0.1000
β2 0.1600 0.2500 0.1000 0.1000
β3 0.1000 0.1000 0.2500 0.1600
β4 0.1000 0.4000 0.2500 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 pi C
s1 p1 w1
. . .
. . .
. . .
sq pq wq
Ejemplo: q=5 X={a,b,c}
S pi C3 Otros códigos para esta Fuente-S son: C4 C5 C6

1/5 aa aa ab
s1 b
bb a ba
s2 1/5 c cc b abb
s3 1/5 aa ab bb aba
s4 1/5 ab ba c ca
s5 1/5 ac
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 S0 = C
S1 = (C/C) – {λ}
∀ i≥1 Si+1 = (C/Si) ∪ (Si/C) ∀ i≥0 Si+1 = [ (C/Si) ∪ (Si/C) ] – {λ}
Cuando Sj = Sk (j<k) entonces nos Cuando Sj = Sk (j<k) entonces nos

detenemos. detenemos.
∞ ∞
Z= U Si
i =1
(nótese que i empieza en 1) Z= U= S
i 1
i (nótese que i empieza en 1)
C es unívocamente decodificable C es unívocamente decodificable

si y sólo si si y sólo si
λ∉ Z 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 1
i ={}
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 1
i = {λ,a,b,ab,ba,bb,ca,aba,abb}
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.
S pi C Supongamos que una secuencia de símbolos del alfabeto código

s1 1/4 w1=0 comienza así: 01 ···
Los puntos suspensivos indican que ignoramos lo que sigue después
s2 1/4 w2=01
(incluso ignoramos si hay símbolos después).
s3 1/4 w3=011 ¿ Podemos asociar (instantáneamente) y sin dudar una palabra código
s4 1/4 w4=0111 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.
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
∑ r – li ≤ 1
i =1
En principio probaremos sólo uno de los sentidos del enunciado.

q
Si ∑ r – li ≤ 1 entonces existe un código instantáneo C r-ario con longitudes l1, …, lq
i =1
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 ∑ r – li = 2– 1 + 2– 2 = 1/2 + 1/4 = 3/4 ≤ 1
i =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
∑ r – li = 2– 2 + 2– 2 + 2– 3 + 2– 3 + 2– 4 ≤ 1 (luego existe C con tales li)
i =1
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 l
∑ r – li = ∑ ni · r –i donde ni: # de términos de la suma del tipo r –i
i =1 i =1
Luego, la hipótesis del enunciado –que se asume verdadera- se puede reescribir así:
l
∑ ni · r –i ≤ 1 Es claro que 0 ≤ ni
i =1
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 transitividad-
0 ≤ 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 transitividad-

0 ≤ 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, Cuide que n1 ≤ r

elija n1 palabras código de longitud 1. De lo contrario habría singularidad.
Elija n2 palabras código de longitud 2. Pero como ya eligió n1 palabras de
De esas hay: longitud 1, esas no pueden ser prefijo de
símbolo 1º símbolo 2º ninguna otra, es decir, cuide que el 1º
cualquiera de r cualquiera de r símbolo no sea cualquiera de r, sino
cualquiera de r- n1; el 2º símbolo sí puede
Es decir, pueden construirse ser cualquiera de r; así sólo puede elegir
arbitrariamente hasta r·r = r2 palabras de entre (r-n1)·r, es decir,
código de longitud 2. n2 ≤ r2 - n1· r
Elija n3 palabras código de longitud 3. Pero, para preservar que C sea libre de
De esas hay: prefijos, cuide que los dos primeros
símbolos 1º y 2 º símbolo 3 º símbolos no sean los ya elegidos. Estos
r2 r eran a lo más (r-n1)·r= r2-n1· r, debe
restárseles los n2 ya elegidos en el paso
Es decir, pueden construirse anterior, es decir, los dos primeros
arbitrariamente hasta r2·r = r3 palabras símbolos pueden ser cualquiera de
código de longitud 3. 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 ∑ r – li = 3– 2 + 3– 2 + 3– 3 = 1/9 + 1/9 + 1/27 = 7/27
i =1
= 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 ∑ r – li ≤ 1 entonces existe un código instantáneo C r-ario con longitudes l1, …, lq
i =1
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 = ∑ r lj – li (para j=2,…,q)
i =1
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 q
∑ r – li = 1/4 + 1/4 + 1/8 + 1/8 + 1/16 ∑ r – li = 1/9 + 1/9 + 1/27 + 1/27 + 1/81
i =1 i =1
= 13/16 ≤ 1 = 25/81 ≤ 1
Construyamos C: Construyamos C:
Fase I: Fase II: Fase I: Fase II:
v1 = 0 w1 = 00 v1 = 0 w1 = 00
v2 = 1 w2 = 01 v2 = 1 w2 = 01
v3 = 4 w3 = 100 v3 = 6 w3 = 020
v4 = 5 w4 = 101 v4 = 7 w4 = 021
v5 = 12 w5 = 1100 v5 = 24 w5 = 0220
Los ceros en negrita son los que se Los ceros en negrita son los que se
añadieron a la izquierda. 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 (10)2 = 1010 (15)2 = 1111
log2(8) = 3.0 log2(10) = 3.321 log2(15) = 3.9
log2(16) = log2(24) = 4
log2(16) = log2(24) = 4
Si 24 ≤ num < 25
Por ej.
(16)2 = 10000 (22)2 = 10110 (31)2 = 11111
log2(16) = 4.0 log2(22) = 4.459 log2(31) = 4.954
log2(32) = log2(25) = 5
log3(9) = log3(32) = 2
Si 32 ≤ num < 33
Por ej.
(9)3 = 100 (17)3 = 122 (26)3 = 222
log3(9) = 2.0 log3(17) = 2.578 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) ∑ r – li < 1
i =1
j −1 q
En efecto, ∑ r – li < ∑ r – li Pues j=2,…,q ; es decir, j≤q, luego (j-1)<q
i =1 i =1
y la primera sumatoria sólo llega hasta (j-1)
≤1 Por hipótesis
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 ) Pues la variable de la sumatoria es i
i =1
j −1
= logr (r lj ) + logr ( ∑ r – li ) Logaritmo de un producto
i =1
j −1
= lj + logr ( ∑ r – li ) Obvio
i =1
(4) logr (vj) < lj
En efecto,
j −1
logr (vj) = lj + logr ( ∑ r – li) Por (3)
i =1
j −1
< lj Pues logr ( ∑ r – li) < 0 por (2)
i =1
(5) Se sabe que [y] ≤ y
(6) [logr (vj)] < lj Por (5) y (4)
Luego,
(7) [logr (vj)] + 1 ≤ lj 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 j −1
En efecto, sabemos que: vj = ∑ r lj – li
= r lj – l1
+ ∑ r lj – li
i =1 i =2
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<k)
y hallaremos una contradicción.
En efecto. Supongamos que wj es prefijo de otro wk.
¿ Cuándo algún wj es prefijo de otro wk ?
Ninguno de los siguientes dos casos son posibles.
1) wj = 0.…...0uj’ ( uj’ son los restantes símbolos de wj)
wk = 0……0…0uk’ ( uk’ son los restantes símbolos de wk)
Aquí se supone que el primer símbolo de uj’ no es ‘0’ (tampoco el de uk’).
Supongamos que el primer símbolo de uj’ es el h-ésimo de wj, pero entonces el h-ésimo
símbolo de wk que es ‘0’ (“a la misma altura” -diríamos gráficamente-) no coincide. Luego
wj no puede ser prefijo de wk evidentemente.
2) wj = 0.…...0uj’ ( uj’ son los restantes símbolos de wj)
wk = 0…0uuuuuuk’ ( uk’ son los restantes símbolos de wk)
Aquí se supone que el primer símbolo de uuuuuuk’ no es ‘0’(tampoco el de uj’, se anota
uuuuuuk’ en vez de uk’ sólo por comodidad para el lector, para que intente ver a wj como
prefijo de wk gráficamente).
Supongamos que el primer símbolo de uuuuuuk’ es el h-ésimo de wk, pero entonces el h-
ésimo símbolo de wj que es ‘0’ (“a la misma altura” -diríamos gráficamente-) no coincide.
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<k y que [ ] denota la parte entera)
Es decir,
(1) wj es prefijo de wk cuando vj = [vk / r lk – lj ]

j −1 k −1
(2) vk / r lk – lj
= ∑ r lj – li
+1+ ∑ r lj – li
i =1 i = j +1
En efecto:
k −1
vk / r lk – lj = ( ∑ r lk – li ) / ( r lk – lj ) Por definición de vk
i =1
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
i =1
k −1
= ∑ r lj – li Obvio
i =1
j −1 k −1
= ∑ r lj – li + ∑
i= j
r lj – li Pues j<k
i =1
j −1 j k −1
= ∑ r lj – li + ∑ r lj – li +
i= j
∑ r lj – li Obvio (véase bien los rangos de i)
i =1 i = j +1
j −1 k −1
= ∑ r lj – li + r lj – lj + ∑ r lj – li Obvio
i =1 i = j +1
j −1 k −1
= ∑ r lj – li + 1 + ∑ r lj – li Obvio
i =1 i = j +1
(3) [y] +1 > y Obvio
(4) [vk / r lk – lj ] + 1 > vk / r lk – lj Por (3)
(5) vj + 1 > vk / r lk – lj Pues vj = [vk / r lk – lj] y
de (4)
39
j −1 k −1
(6) vj + 1 > ∑ r lj – li + 1 + ∑ r lj – li Por (2)
i =1 i = j +1
j −1 k −1 j −1 k −1
(7) ∑ r lj – li + 1 + ∑ r lj – li ≥ ∑ r lj – li + 1 Pues ∑ r lj – li puede ser vacua
i =1 i = j +1 i =1 i = j +1
j −1 k −1 j −1
(8) vj + 1 > ∑ r lj – li + 1 + ∑ r lj – li ≥ ∑ r lj – li + 1 Juntando (6) y (7)
i =1 i = j +1 i =1
j −1
(9) vj + 1 > ∑ r lj – li + 1 De (8)
i =1
j −1
(10) vj + 1 > vj + 1 Pues vj = ∑ r lj – li
i =1
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
∑ r – li ≤ 1
i =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 ∑ r – li ≤ 1
i =1
q
Sea K = ∑ r – li
i =1
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 -l2 + r -l3 + r -l4)
=
r -l1·r -l1·(r -l1 + r -l2 + r -l3 + r -l4) + r –l2·r -l1·(r -l1 + r -l2 + r -l3 + r -l4)
+ r -l1·r -l2·(r -l1 + r -l2 + r -l3 + r -l4) + r –l2·r -l2·(r -l1 + r -l2 + r -l3 + r -l4)
+ r -l1·r -l3 ·(r -l1 + r -l2 + r -l3 + r -l4) + r –l2·r -l3·(r -l1 + r -l2 + r -l3 + r -l4)
+ r -l1·r -l4·(r -l1 + r -l2 + r -l3 + r -l4) + r –l2·r -l4·(r -l1 + r -l2 + r -l3 + r -l4)
+ r –l3·r -l1·(r -l1 + r -l2 + r -l3 + r -l4) + r –l4·r -l1·(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 –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 –l3·r -l1·r -l1 + r –l3·r -l1·r –l2 + r –l3·r -l1·r –l3 + r –l3·r -l1·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
(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)



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) [n veces]
q q
= ∑ … ∑ r –(li1+ … +lin)
i1=1 in =1
Sea l=max{l1, …, lq}.

Si utilizamos el mismo razonamiento que en el Teorema de Kraft, esta sumatoria puede
reescribirse así:
q q n· l
∑ … ∑ r –(li1+ … +lin) = ∑
i =n
Ni · r –i
i1=1 in=1
donde Ni: # de términos de la suma del tipo r –i
q n· l
Es decir, K = ( ∑ r – li)n =
n
∑ Ni · r –i
i =1 i =n
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 w2 w1 w1 | l2 + l1 + l1 w3 w1 w1 | l3 + l1 + l1 w4 w1 w1 | l4 + l1 + l1
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 q q
Kn = ( ∑ r – li)n = ∑ … ∑ r –(li1+ … +lin)
i =1 i1=1 in=1
Entonces también Ni puede representar el # de palabras código –en Cn – de longitud i.

Resumiendo:
q n· l
Kn = ( ∑ r – li)n = ∑ Ni · r –i
i =1 i =n
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.
Ni ≤ ri
44
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,
n· l n· l
Kn = ∑
i =n
Ni · r –i ≤ ∑
i =n
r i · r –i Pues Ni ≤ ri
n· l n· l n· l
= ∑
i =n
r i–i = ∑
i =n
r0 = ∑
i =n
1 Obvio
= n· l - n + 1 Obvio
Es decir,
q
( ∑ r – li)n = Kn ≤ n· l - n + 1 y como n· l - n + 1≤ n· l, entonces
i =1
q
( ∑ 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
∑ r – li ≤ 1.
i =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 ∑ r – li ≤ 1 [McMillan]
i =1
q
2) Si ∑ r – li ≤ 1
i =1
entonces existe un código instantáneo C r-ario con longitudes l1, …, lq [Kraft]
3) Si C es un código instantáneo entonces C es unívocamente decodificable [página 29]
Lícitamente podemos reescribir 3 como:
3') Si ∃ C un código instantáneo entonces ∃ C unívocamente decodificable
Luego, de 3' y 1, por transitividad:

4) Si ∃ C un código instantáneo r-ario con longitudes l1, …, lq
q
entonces ∑ r – li ≤ 1
i =1
También, de 2 y 3', por transitividad:
q
5) Si ∑ r – li ≤ 1
i =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 ∃ C un código unívocamente decodificable

con longitudes l1, …, lq r-ario con longitudes l1, …, lq
si y sólo si si y sólo si
q q
∑ r – li
≤1 ∑ r – li ≤ 1
i =1 i =1
Que es el Teorema de Kraft. 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 f(x) = (x -1) - ln(x)

La primera derivada es f '(x) = 1 - 1/x
La segunda derivada es 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) o, lo que es lo mismo, ln(x) ≤ x - 1
47
LEMA DE GIBBS
Si {x1, ..., xq}, {y1, ..., yq} son dos conjuntos de números tales que
q q
xi ≥ 0, yi ≥ 0 además que ∑ xi = 1, ∑ yi = 1
i =1 i =1
Entonces
q q
∑ xi· ln(1/xi) ≤ ∑ xi· ln(1/yi)
i =1 i =1
Demostración:
q q
∑ xi· ln(1/xi) - ∑ xi· ln(1/yi)
i =1 i =1
q
= ∑ [ xi· ln(1/xi) - xi· ln(1/yi) ] propiedades de sumatoria
i =1
q
= ∑ xi · [ ln(1/xi) - ln(1/yi) ] factorizando xi
i =1
q
= ∑ xi · [ ln( (1/xi) / (1/yi) )] ln(a/b) = ln a - ln b
i =1
q
= ∑ xi · [ ln(yi /xi)] medios con medios, extremos con extremos
i =1
q
≤ ∑ x i · [yi/xi - 1] pues ln(z) ≤ z -1 (igualdad en z=1) (aquí z= yi/xi)
i =1
q
= ∑ [ yi - xi ] distribuyendo xi
i =1
q q
= ∑ yi - ∑ xi 'desdoblando' la sumatoria
i =1 i =1
= 1 - 1 por los supuestos del lema
= 0
Resumiendo:
q q
∑ xi· ln(1/xi) - ∑ xi· ln(1/yi) ≤ 0
i =1 i =1
q q
Es decir, ∑ xi· ln(1/xi) ≤ ∑ xi· ln(1/yi)
i =1 i =1
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
Recordemos que Hr(S) = ∑ pi · logr 1/pi r-its
i =1
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 q
Es claro que xi ≥ 0, yi ≥ 0 además que ∑ xi = 1, ∑ yi = 1
i =1 i =1
Es decir, los supuestos de Gibbs se mantienen y podemos aplicar el lema. Luego,
q q
∑ pi · ln(1/pi) ≤ ∑ pi · ln(q) O su equivalente:
i =1 i =1
q q
∑ pi · logr(1/pi) /logr(e) ≤ ∑ pi · logr(q) /logr(e) pues ln(z)=logr(z)/logr(e)
i =1 i =1
q q
∑ pi · logr(1/pi) ≤ ∑ pi · logr(q) cancelando logr(e) (logr(e)>0)
i =1 i =1
q
Hr(S) ≤ ∑ pi · logr(q) por definición de entropía
i =1
q
Hr(S) ≤ logr(q) ∑ pi pues logr(q) no depende de i
i =1
Hr(S) ≤ logr(q) 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] pues prob(σj) = prob(sj1 sj2 ... sjn)
j=1
= 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 q
= ∑ … ∑ [pi1 · pi2 · ... · pin ] · [logr 1/pi1 · pi2 · ... · pin]
i1=1 in =1
q q
=∑ … ∑ [pi1 · pi2 · ... · pin ] · [logr (1/pi1 · 1/pi2 · ... · 1/pin)] reescribiendo el 2o corchete
i1=1 in =1
q q
=∑ … ∑ [pi1 · pi2 · ... · pin ] · [logr(1/pi1 ) + logr(1/pi2 ) ... + logr(1/pin)] log de producto
i1=1 in =1
q q
=∑ … ∑ [pi1 · pi2 · ... · pin ] · logr(1/pi1 ) distribuyendo el primer corchete
i1=1 in =1
q q
+∑ … ∑ [pi1 · pi2 · ... · pin ] · logr(1/pi2) e introduciendo las
i1=1 in =1
... sumatorias
q q
+∑ … ∑ [pi1 · pi2 · ... · pin ] · logr(1/pin)
i1=1 in =1
= H(S) pues cada uno de los

+ H(S) n sumandos
... es igual a la entropía H(S)
+ H(S) como enseguida probaremos.
= n·H(S) Que es lo que queríamos demostrar
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:
50
Caso i1:
q q
∑ … ∑ [pi1 · pi2 · ... · pin ] · logr(1/pi1)
i1=1 in=1
q q
=∑ … ∑ [pi1 · logr(1/pi1)] · pi2 · ... · pin Obvio
i1=1 in =1
q q q
= ∑ [pi1 · logr(1/pi1)] ∑ … ∑ pi2 · ... · pin Pues i1 no depende de i2,..., in
i1=1 i 2=1 in=1
q q q q
= ∑ [pi1 · logr(1/pi1)] ∑ pi2 ∑ pi 3 … ∑ pin Obvio
i1=1 i 2=1 i3=1 in =1
q
= ∑ [pi1 · logr(1/pi1)] · 1 Cada sumatoria es igual a 1.
i1=1
= H(S) Obvio
Caso in:
q q
∑ … ∑ [pi1 · pi2 · ... · pin ] · logr(1/pin)
i1=1 in=1
q q
=∑ … ∑ pi1 · ... · pin-1 · [pin · logr(1/pin)] Obvio
i1=1 in =1
q q q
=∑ … ∑ pi1 · ... · pin-1 ∑ pin · logr(1/pin) Pues i1,...,in-1 no dependen de in
i1=1 i ( n−1)=1 in=1
q q q q
= ∑ pi1 ∑ pi2 … ∑ pin-1 ∑ pin · logr(1/pin) Obvio
i1=1 i 2=1 i ( n−1)=1 in=1
q q q
= ∑ pi1 ∑ pi2 … ∑ pin-1 · H(S) Obvio
i1=1 i 2=1 i ( n−1)=1
q q q
= H(S) · ∑ pi1 ∑ pi2 … ∑ pin-1 Obvio
i1=1 i 2=1 i ( n−1)=1
= H(S) · 1 Cada sumatoria es igual a 1.
= H(S) 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 q
= ∑ wj ∑ p(si / αj) · logr (1/ p(si / αj)) definición de Hr (S / αj)
j =1 i =1
qm q
=∑ ∑ wj · p(si / αj) · logr (1/ p(si / αj)) wj ingresa a la sumatoria
j =1 i =1
q qm
=∑ ∑ wj · p(si / αj) · logr (1/ p(si / αj)) conmutando las sumatorias
i =1 j =1
Aquí: wj = prob(αj) = prob(sj1 sj2 ... sjm)
q
Por otro lado, Hr ( M ) = ∑ prob(si) · logr (1/prob(si)) r-its
i =1
qm qm
Donde prob(si) = pi = ∑ p(si /αj) · wj = ∑ wj · p(si /αj)
j =1 j =1
q qm
Es decir, Hr ( M ) = ∑ [ ∑ wj · p(si /αj) ] · logr (1/prob(si))
i =1 j =1
q qm
=∑ ∑ wj · p(si /αj) · logr (1/prob(si)) r-its
i =1 j =1
Entonces,
Hr (M) - Hr ( M )
q qm
=∑ ∑ wj · p(si / αj) · logr (1/ p(si / αj))
i =1 j =1
-
q qm
∑ ∑ wj · p(si /αj) · logr (1/prob(si)) luego, 'juntando' las sumatorias
i =1 j =1
52
q qm
=∑ ∑ [ wj · p(si / αj) · logr (1/ p(si/αj)) - wj · p(si /αj) · logr (1/prob(si)) ]
i =1 j =1
q qm
=∑ ∑ wj · p(si /αj) · [ logr (1/ p(si/αj)) - logr (1/prob(si)) ] factorizando wj · p(si /αj)
i =1 j =1
q qm
=∑ ∑ wj · p(si /αj) · logr [ (1/ p(si/αj)) / ( 1/prob(si) ) ] log de un cociente
i =1 j =1
q qm
=∑ ∑ wj · p(si /αj) · logr [prob(si)/p(si/αj)] medios con medios, etc.
i =1 j =1
q qm
= [1/ln(r)] · ∑ ∑ wj · p(si /αj) · ln[prob(si)/p(si/αj)] pues logr(z)= ln(z)/ln(r)
i =1 j =1
q qm
≤ [1/ln(r)] · ∑ ∑ wj · p(si /αj) · [prob(si)/p(si/αj) - 1] pues ln(z) ≤ z-1
i =1 j =1
q qm
= [1/ln(r)] · ∑ ∑ [ wj · prob(si) - wj · p(si /αj) ] distribuyendo wj · p(si /αj)
i =1 j =1
q qm q qm
= [1/ln(r)] · [ ∑ ∑ wj · prob(si) - ∑ ∑ wj · p(si /αj) ] obvio
i =1 j =1 i =1 j =1
q qm q qm
= [1/ln(r)] · [ ∑ prob(si) ∑ wj - ∑ ∑ wj · p(si /αj) ] prob(si) no depende de j
i =1 j =1 i =1 j =1
q q qm qm
= [1/ln(r)] · [ ∑ prob(si) [ 1 ] - ∑ ∑ wj · p(si /αj) ] pues ∑ wj =1
i =1 i =1 j =1 j =1
q q qm
= [1/ln(r)] · [ ∑ prob(si) - ∑ ∑ wj · p(si /αj) ] obvio
i =1 i =1 j =1
q q
= [1/ln(r)] · [ ∑ prob(si) - ∑ prob(si) ] cálculo de prob(si)
i =1 i =1
=0 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
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} con X={0,1}
Es claro que l1=1, l2=2, l3=3
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 q
L(C) = ∑ pi · li = ∑ 1/q · li = 1/q · ∑ li
i =1 i =1 i =1
Nótese que cuando el código C es bloque, entonces:

q q q
L(C) = ∑ pi · li = ∑ pi · l = l · ∑ pi = l · 1 = l
i =1 i =1 i =1
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 pi C C'
s1 p1 w1 w'1 = w1
... ... ... ...
si pi wi w'i = wj
... ... ... ...
sj pj wj w'j = wi
... ... ... ...
sq pq wq w'q = wq
Supongamos que li > lj

L(C) - L(C') = L(C) = p1 · l1 + ... + pi · li + ...+ pj · lj + ... + pq · lq
- L(C') - [ p1 · l1 + ... + pi · lj + ...+ pj · li + ... + pq · lq ]
= pi · li + pj · lj obvio
- pi · lj - pj · li
= pi · li - pi · lj + pj · lj - pj · li reescribiendo
= pi · (li - lj) + pj · (lj - li) factorizando
= pi · (li - lj) - pj · (li - lj) obvio
= (pi - pj) · (li - lj) factorizando
> 0 pi > pj, o sea (pi - pj) > 0
li > lj, o sea (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
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')<L(C), es decir, que C no es compacto (pero C sí es compacto).
Contradicción que muestra lo erróneo del supuesto y que va' ∈ C.
Lo que nos lleva al inciso a).

Si va' ∈ C, con wq-1=va' el enunciado ya está demostrado.
En cambio si va' ∈ C, con wi=va' (i ≠ q-1)

A partir de C construimos el código C' intercambiando las palabras código asociadas al
símbolo si (wi) y al símbolo sq-1 (wq-1) (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 + ... + pq-1 · lq-1 + pq · lq
L(C') = p1 · l1 + ... + pi · lq-1 + ... + pq-1 · li + pq · lq
Como -en C- wi=va' y wq=va es claro que |wi|=|va'|=li y |wq|=|va|= lq
Luego li=lq
Dado que pi ≥ ... ≥ pq-1 se cumple que li ≤ ... ≤ lq-1
Es decir, li=li+1=...=lq-1=lq. Así pues, la igualdad L(C')=L(C) es evidente.
Y como C es compacto es claro que C' también es compacto.
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
i =1 i =1
q q
= ∑ pi · logr(1/pi) - ∑ pi · logr(r li ) exponencial y log son inversas
i =1 i =1
q
= ∑ [ pi · logr(1/pi) - pi · logr(r li ) ] 'uniendo' las sumatorias
i =1
q
= ∑ pi · [ logr(1/pi) - logr(r li ) ] factorizando pi
i =1
q
= ∑ pi · logr(1/pi / r li ) log(a/b) = log a - log b
i =1
q
= ∑ pi · logr(1 / (pi · r li ) ) medios con medios, etc.
i =1
q
= [1/ln(r)] · ∑ pi · ln(1 / (pi · r li ) ) pues logr(z)= ln(z)/ln(r)
i =1
q
≤ [1/ln(r)] · ∑ pi · [1 / (pi · r li ) - 1] pues ln(z) ≤ z-1
i =1
q
= [1/ln(r)] · ∑ [ 1 / r li - pi ] distribuyendo pi
i =1
q q
= [1/ln(r)] · [ ∑ 1/r li
- ∑ pi ] introduciendo la sumatoria
i =1 i =1
q q
= [1/ln(r)] · [ ∑ r – l i - ∑ pi ] obvio
i =1 i =1
q
= [1/ln(r)] · [ ∑ r – l i - 1 ] obvio
i =1
≤0
q
Pues ∑ r – l i ≤ 1 ya que como C es unívocamente decodificable (o instantáneo) el
i =1
teorema de McMillan (o Kraft) garantiza esto. Así pues Hr(S) - L(C) ≤ 0, es decir:
Hr(S) ≤ L(C).
q
La igualdad se da cuando [1 / (pi · r )] = 1 y li
∑ r – l i = 1. Pero cuando pi = r – l i,
i =1
despejando li se verifica la igualdad cuando li=logr(1/pi), pues la segunda condición
q q
∑ r –li
= ∑ pi =1 se cumple siempre. Para tener sentido logr(1/pi) debe ser un entero.
i =1 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) ] [x 100%]

La redundancia de C se define como η' = [1-η] [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 q q
∑ r –li ≤ ∑ pi = 1, es decir, ∑ r –li ≤ 1
i =1 i =1 i =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 q q q
∑ pi · logr(1/pi) ≤ ∑ pi · li < ∑ pi · logr(1/pi) + ∑ pi · 1
i =1 i =1 i =1 i =1
Que no es otra cosa que.
Hr(S) ≤ L(C) < Hr(S) + 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 dado que Hr(Sn) = n·Hr(S), resulta:
n·Hr(S) ≤ L(Dn) < n·Hr(S) + 1 multiplicando cada miembro por 1/n resulta:
Hr(S) ≤ L(Dn)/n < Hr(S) + 1/n Luego:
lim L(Dn)/n = Hr(S)
n −> ∞
n
El resultado sigue si tomamos L(D )/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
s2 3/13 sα 4/13 10 pα = pα0 + pα1 = 2/13 + 2/13 = 4/13
sα0 2/13 s2 3/13 11
sα1 2/13
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 sα 4/13 10
sα0 2/13 100 s 2 3/13 11
sα1 2/13 101
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α1-
La 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
... ... ... ... ... ... ... ...
sα0 pα0 vα0=v0 wα0 sα pα v 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| obvio
= pα0·(|v|+1) + pα1·(|v| +1) - pα·|v| pues |vc|=|v|+1
= pα0·|v| + pα0 + pα1·|v| + pα1 - pα·|v| obvio
= pα0·|v| + pα0 + pα1·|v| + pα1 - (pα0+pα1)·|v| pues pα=pα0+pα1
= pα0 + pα1 = pα obvio
Luego L(Dj-1) = pα + L(Dj)
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} (r = 3)
S C S2 C2
1/4 1 3/4 0
1/4 00 1/4 1
1/4 01
1/4 02
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
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
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" m=3

S pij Acumij
s1 0.7 0.7
s2 0.2 0.9
s3 0.1 1
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 D símbolo
decodificado
0 1 1
0.8985 2 0.7 0.2 0.9 s2 val∈ [0.7, 0.9[
0.9925 3 0.88 0.02 0.9 s3 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
b1 b2 ... ... bs-1 bs
e a1 p(b1/a1) p(b2/a1) ... ... p(bs-1/a1) p(bs/a1)
n a2 p(b1/a2) p(b2/a2) ... ... p(bs-1/a2) p(bs/a2)
t ... ... ... ... ...
P= r .
a . p(bj/ai)
d ... ... ... ... ...
a ar-1 p(b1/ar-1) p(b2/ar-1) ... ... p(bs-1/ar-1) p(bs/ar-1)
s ar p(b1/ar) p(b2/ar) ... ... p(bs-1/ar) p(bs/ar)
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(a1)=1/2 p(a2)=1/2
b1 b2 b3
P= a1 1/2 0 1/2
a2 1/3 1/3 1/3
P en forma de listado:
p(b1/a1)=1/2 p(b2/a1)=0 p(b3/a1)=1/2
p(b1/a2)=1/3 p(b2/a2)=1/3 p(b3/a2)=1/3
Como mencionamos antes, puede presentarse un 'grafo del canal' así:

1/2
a1 b1
1/2 1/3
b2
1/3
a2 b3
1/3
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
∑ p(bj/ai) = p(b1/ai) + ... + p(bs/ai) = 1
j=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
p(bj) = ∑ p(bj/ai) · p(ai) = ∑ p(ai,bj)
i =1 i =1
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 de la salida:

entropía a priori de A:
r s
H(A) = ∑ p(ai) · log[1/p(ai)] H(B) = ∑ p(bj) · log[1/p(bj)]
i =1 j=1
Entropía a posteriori de A dado bj: Entropía condicional de B dado ai
r s
H(A/bj) = ∑ p(ai/bj) · log[1/p(ai/bj)] H(B/ai) = ∑ p(bj/ai) · log[1/p(bj/ai)]
i =1 j=1
Equivocación de A con respecto a B ó Equivocación de B con respecto a A
equivocación del canal:
H(A/B) H(B/A)
s r
= ∑ p(bj) · H(A/bj) = ∑ p(ai) · H(B/ai)
j=1 i =1
s r r s
= ∑ p(bj) · ∑ p(ai/bj) · log[1/p(ai/bj)] = ∑ p(ai) · ∑ p(bj/ai) · log[1/p(bj/ai)]
j=1 i =1 i =1 j=1
s r r s
=∑ ∑ p(bj) · p(ai/bj) · log[1/p(ai/bj)] =∑ ∑ p(ai) · p(bj/ai) · log[1/p(bj/ai)]
j=1 i =1 i =1 j=1
s r r s
=∑ ∑ p(ai,bj) · log[1/p(ai/bj)] =∑ ∑ p(ai,bj) · log[1/p(bj/ai)]
j=1 i =1 i =1 j=1
Información mutua entre A y B Información mutua entre B y A
I(A;B) = H(A) - H(A/B) I(B;A) = H(B) - H(B/A)

Entropía conjunta:
r s
H(A,B) = ∑ ∑ p(ai,bj) · log[1/p(ai,bj)]
i =1 j=1
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}
b1 b2 b3
P= a1 1/2 0 1/2
a2 1/3 1/3 1/3
p(a1) = 1/2 p(a2) = 1/2

H(A) = 1 bit
p(b1) = 5/12 p(b2) = 2/12 p(b3) = 5/12

H(B) = 1.4834 bits
H(A/B) = 0.80912549537889 bits

H(B/A) = 1.29248125036058 bits
H(A,B) = 2.29248125036058 bits
I(A;B) = 0.19087450462111 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 s
= ∑ p(ai) · log[1/p(ai)] · [ ∑ p(bj/ai)] pues ∑ p(bj/ai) = 1
i =1 j=1 j=1
r s
=∑ ∑ p(ai) · log[1/p(ai)] · p(bj/ai) propiedades de sumatoria
i =1 j=1
r s
=∑ ∑ p(bj/ai) · p(ai) · log[1/p(ai)] conmutatividad
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[1/p(ai)] pues p(bj/ai) · p(ai) = p(ai,bj)
i =1 j=1
2) Ya vimos que:
s r
H(A/B) = ∑ ∑ p(ai,bj) · log[1/p(ai/bj)]
j=1 i =1
r s
=∑ ∑ p(ai,bj) · log[1/p(ai/bj)] propiedades de sumatoria
i =1 j=1
De 1 y 2:
I(A;B)
= H(A) - H(A/B)
r s r s
=∑ ∑ p(ai,bj) · log[1/p(ai)] - ∑ ∑ p(ai,bj) · log[1/p(ai/bj)]
i =1 j=1 i =1 j=1
r s
=∑ ∑ { p(ai,bj) · log[1/p(ai)] - p(ai,bj) · log[1/p(ai/bj)] } propiedades de sumatoria
i =1 j=1
r s
=∑ ∑ p(ai,bj) · { log[1/p(ai)] - log[1/p(ai/bj)] } factorizando p(ai,bj)
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[ 1/p(ai) / 1/p(ai/bj)] log a - log b=log a/b
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[p(ai/bj) / p(ai)] medios con medios, etc.
i =1 j=1
75
r s
= ∑ ∑ p(ai,bj) · log[p(ai) / p(ai/bj)]-1 propiedades de exponente
i =1 j=1
r s
=- ∑ ∑ p(ai,bj) · log[p(ai) / p(ai/bj)] propiedades de logaritmo
i =1 j=1
r s
=- ∑ ∑ p(ai,bj) · log[p(ai) · p(bj) / p(ai/bj) · p(bj)] obvio
i =1 j=1
r s
=- ∑ ∑ p(ai,bj) · log[p(ai) · p(bj) / p(ai,bj)] pues p(ai/bj) · p(bj) = p(ai,bj)
i =1 j=1
Resumiendo:
r s
I(A;B) = - ∑ ∑ p(ai,bj) · log[p(ai) · p(bj) / p(ai,bj)]
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
∑ ∑ p(ai,bj) · log{p(ai) · p(bj) / p(ai,bj)} la base del logaritmo es V
i =1 j=1
r s
= [1/ln(V)] · ∑ ∑ p(ai,bj) · ln{p(ai) · p(bj) / p(ai,bj)} propiedades de logaritmo
i =1 j=1
r s
≤ [1/ln(V)] · ∑ ∑ p(ai,bj) · {[p(ai) · p(bj) / p(ai,bj)] - 1} pues ln(z) ≤ z-1
i =1 j=1
r s
= [1/ln(V)] · ∑ ∑ {p(ai,bj) · [p(ai) · p(bj) / p(ai,bj)] - p(ai,bj)} distribuyendo p(ai,bj)
i =1 j=1
r s
= [1/ln(V)] · ∑ ∑ {p(ai) · p(bj) - p(ai,bj)} obvio
i =1 j=1
r s r s
= [1/ln(V)] ·{ ∑ ∑ p(ai) · p(bj) - ∑ ∑ p(ai,bj)} propiedades de sumatoria
i =1 j=1 i =1 j=1
r s r s
= [1/ln(V)] ·{ ∑ p(ai) · ∑ p(bj) - ∑ ∑ p(ai,bj)} p(ai) no depende de j
i =1 j=1 i =1 j=1
r r s s
= [1/ln(V)] ·{ ∑ p(ai) · 1 -∑ ∑ p(ai,bj)} pues ∑ p(bj) = 1
i =1 i =1 j=1 j=1
r r s
= [1/ln(V)] ·{ ∑ p(ai) - ∑ ∑ p(ai,bj)} obvio
i =1 i =1 j=1
r r s
= [1/ln(V)] ·{ ∑ p(ai) - ∑ ∑ p(bj/ai) · p(ai)} pues p(ai,bj) = p(bj/ai) · p(ai)
i =1 i =1 j=1
r r s
= [1/ln(V)] ·{ ∑ p(ai) - ∑ p(ai) · ∑ p(bj/ai)} p(ai) no depende de j
i =1 i =1 j=1
76
r r s
= [1/ln(V)] ·{ ∑ p(ai) - ∑ p(ai) · 1} pues ∑ p(bj/ai) = 1
i =1 i =1 j=1
r r
= [1/ln(V)] ·{ ∑ p(ai) - ∑ p(ai) } obvio
i =1 i =1
= [1/ln(V)] ·{ 0 } obvio
=0 obvio
Resumiendo:
r s
∑ ∑ p(ai,bj) · log{p(ai) · p(bj) / p(ai,bj)} ≤ 0
i =1 j=1
Luego, incluyendo al signo menos, resulta:
r s
- ∑ ∑ p(ai,bj) · log{p(ai) · p(bj) / p(ai,bj)} ≥ 0
i =1 j=1
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
RECIPROCIDAD DE LA INFORMACIÓN MUTUA
I(A;B) = I(B;A)
Demostración:
r r
1) ∑ p(ai/bj) = ∑ p(bj/ai) · p(ai) / p(bj) por Bayes
i =1 i =1
r
= [1/p(bj)] · ∑ p(bj/ai) · p(ai) pues p(bj) es independiente de i
i =1
= [1/p(bj)] · p(bj) cálculo de p(bj)
=1
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)] por 1)
j=1 i =1
s r
=∑ ∑ p(bj) · log[1/p(bj)] · p(ai/bj) propiedades de sumatoria
j=1 i =1
s r
=∑ ∑ p(ai/bj) · p(bj) · log[1/p(bj)] conmutatividad
j=1 i =1
s r
=∑ ∑ p(ai,bj) · log[1/p(bj)] pues p(ai/bj) · p(bj) = p(ai,bj)
j=1 i =1
r s
=∑ ∑ p(ai,bj) · log[1/p(bj)] propiedades de sumatoria
i =1 j=1
3) Ya vimos que:
r s
H(B/A) = ∑ ∑ p(ai,bj) · log[1/p(bj/ai)]
i =1 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/ai)]
i =1 j=1 i =1 j=1
r s
=∑ ∑ { p(ai,bj) · log[1/p(bj)] - p(ai,bj) · log[1/p(bj/ai)] } propiedades de sumatoria
i =1 j=1
78
r s
=∑ ∑ p(ai,bj) · { log[1/p(bj)] - log[1/p(bj/ai)] } factorizando p(ai,bj)
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[1/p(bj) / 1/p(bj/ai)] log a - log b = log a/b
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[p(bj/ai)/p(bj)] medios con medios, etc.
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[p(bj/ai) · p(ai) / p(bj) · p(ai)] obvio
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[p(ai,bj) / p(bj) · p(ai)] pues p(bj/ai) · p(ai) = p(ai,bj)
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[p(ai,bj) / p(ai) · p(bj)] obvio
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[p(ai) · p(bj) / p(ai,bj)]-1 propiedades de exponente
i =1 j=1
r s
= -∑ ∑ p(ai,bj) · log[p(ai) · p(bj) / p(ai,bj)] propiedades de logaritmo
i =1 j=1
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)]
i =1 j=1
r s
=∑ ∑ p(bj/ai) · p(ai) · log[1 / p(bj/ai)·p(ai)] pues p(ai,bj) = p(bj/ai)·p(ai)
i =1 j=1
r s
=∑ ∑ p(bj/ai) · p(ai) · {log[1/p(bj/ai)] + log[1/p(ai)]} log ab=log a+log b
i =1 j=1
r s
=∑ ∑ { p(bj/ai) · p(ai) · log[1/p(bj/ai)] + p(bj/ai) · p(ai) · log[1/p(ai)] } obvio
i =1 j=1
r s
=∑ ∑ p(bj/ai) · p(ai) · log[1/p(bj/ai)]
i =1 j=1
r s
+∑ ∑ p(bj/ai) · p(ai) · log[1/p(ai)] propiedades de sumatoria
i =1 j=1
r s
= ∑ p(ai) · ∑ p(bj/ai) · log[1/p(bj/ai)] p(ai) es independiente de j
i =1 j=1
r s
+∑ ∑ p(bj/ai) · p(ai) · log[1/p(ai)]
i =1 j=1
r
= ∑ p(ai) · H(B/ai) definición de H(B/ai)
i =1
r s
+∑ ∑ p(bj/ai) · p(ai) · log[1/p(ai)]
i =1 j=1
r s
= H(B/A) + ∑ ∑ p(bj/ai) · p(ai) · log[1/p(ai)] definición de H(B/A)
i =1 j=1
r s
= H(B/A) + ∑ p(ai) · log[1/p(ai)] · ∑ p(bj/ai) ; p(ai)·log[1/p(ai)] es independiente de j
i =1 j=1
r s
= H(B/A) + ∑ p(ai) · log[1/p(ai)] · 1 pues ∑ p(bj/ai) = 1
i =1 j=1
= H(B/A) + H(A)
= H(A) + H(B/A) 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(bj/ai)]
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[1·p(ai) / p(bj/ai)·p(ai)] obvio
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[1·p(ai) / p(ai,bj)] pues p(bj/ai)·p(ai) = p(ai,bj)
i =1 j=1
r s
=∑ ∑ p(ai) · p(bj) · log[1·p(ai) / p(ai)·p(bj)] pues p(ai,bj) = p(ai) · p(bj)
i =1 j=1
r s
=∑ ∑ p(ai) · p(bj) · log[1/p(bj)] obvio
i =1 j=1
r s
= ∑ p(ai) · ∑ p(bj) · log[1/p(bj)] p(ai) es independiente de j
i =1 j=1
r
= ∑ p(ai) · H(B) definición de H(B)
i =1
= H(B) obvio
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)] obvio
= H(A) + H(B) - H(A,B) 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 s
=∑ ∑ p(ai,bj) · log[p(ai,bj) / p(ai) · p(bj)]
i =1 j=1
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 : Como I(A;B) ≥ 0 :

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

I(A;B) = H(A) 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
Como H(A/B) = ∑ p(bj) · ∑ p(ai/bj) · log[1/p(ai/bj)]
j=1 i =1
Mostraremos que la segunda sumatoria es una suma de ceros. Luego,
s r s
H(A/B) = ∑ p(bj) · ∑ p(ai/bj) · log[1/p(ai/bj)] = ∑ p(bj) · 0 = 0
j=1 i =1 j=1
En efecto, como
p(ai/bj) = p(bj/ai)·p(ai) / p(bj) por Bayes
r
= p(bj/ai)·p(ai) / ∑ p(bj/ai') · p(ai') cálculo de p(bj), usar i' no afecta
i'=1
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.
r
Para los sumandos tales que p(bj/ai) ≠ 0, es claro que ∑ p(bj/ai') · p(ai') recorre la
i'=1
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(a2) = 1/3
b1 b2 b3
P= a1 1/2 1/2 0
a2 0 0 1
p(b1) = 1/3 p(b2) = 1/3 p(b3) = 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
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
Como H(B/A) = ∑ p(ai) · ∑ p(bj/ai) · log[1/p(bj/ai)]
i =1 j=1
La segunda sumatoria (que recorre la fila ai) se comporta así:
s
∑ p(bj/ai) · log[1/p(bj/ai)] = p(b1/ai) · log[1/p(b1/ai)] + ... + p(bs/ai) · log[1/p(bs/ai)]
j=1
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, ∑ p(bj/ai) · log[1/p(bj/ai)] = 0. Luego,
j=1
r
H(B/A) = ∑ p(ai) · 0 = 0
i =1
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(a3) = 1/3
b1 b2
P= a1 1 0
a2 1 0
a3 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
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(a2) = 2/3
B1 b2
P= a1 1/2 1/2
a2 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
En la definición de H(B/A) = ∑ p(ai) · ∑ p(bj/ai) · log[1/p(bj/ai)]
i =1 j=1
Al ser las filas iguales, la segunda sumatoria da el mismo resultado para cada ai.
s
Sea c tal constante, es decir, ∑ p(bj/ai) · log[1/p(bj/ai)] = c (1)
j=1
Luego:
r r
H(B/A) = ∑ p(ai) · c = c · ∑ p(ai) = c · 1 = c
i =1 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
Luego, p(bj) = ∑ p(bj/ai) · p(ai) = ∑ k · p(ai) = k · ∑ p(ai) = k · 1 = k
i =1 i =1 i =1
Es decir, p(bj) = k = p(bj/ai) (para algún i, el que sea pues las filas son iguales) (2)
s
Por tanto, H(B) = ∑ p(bj) · log[1/p(bj)]
j=1
s
= ∑ p(bj/ai) · log[1/p(bj/ai)] por (2)
j=1
=c 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
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
b1 b2 b3 b4
P= a1 1/2 1/4 1/4 0
a2 1/4 1/2 0 1/4
a3 0 1/4 1/4 1/2
a4 1/4 0 1/2 1/4
Canal débilmente simétrico.- Sea NUM la secuencia: num1, ... ,nums

Su matriz P es tal que:

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
b1 b2 b3 b4
P= a1 1/2 1/4 1/4 0
a2 0 1/4 1/4 1/2
Canal binario simétrico CBS (BSC por las siglas del nombre en inglés, Binary
Symmetric Channel).- Su matriz es así:
b1 b2
P= a1 p q donde q = 1-p
a2 q 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í:
b1 b2 b3
P= a1 p q 0 donde q = 1-p
a2 0 q 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) luego:
p(ai,bj,ck) / p(ai,bj) = p(ai/bj,ck)·p(ck/bj)·p(bj) / p(ai,bj) Por 1)

= p(ai/bj,ck)·p(ck/bj)·p(bj) / p(ai/bj)·p(bj) pues p(ai,bj)=p(ai/bj)·p(bj)
= p(ai/bj,ck)·p(ck/bj) / p(ai/bj) obvio
'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) por 1)
= p(ck/ai,bj)·p(ai/bj) / p(ck/bj) obvio
= p(ck/bj)·p(ai/bj) / p(ck/bj) por i)
= p(ai/bj) 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
H(A/C) = ∑ p(ck) · H(A/ck) = ∑ p(ck) · ∑ p(ai/ck) · log[1/p(ai/ck)]
k =1 k =1 i =1
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
iii) p(bj) = ∑ p(bj/ai) · p(ai) = ∑ p(ai,bj) [cálculo de p(bj)]
i =1 i =1
iv) En el segundo canal -por definición- sus filas deben sumar 1, es decir
t
∑ p(ck/bj) = 1
k =1
v) Análogamente a como se calcula p(bj) en el primer canal, podemos calcular p(ck) en el

segundo así:
s s
p(ck) = ∑ p(ck/bj) · p(bj) = ∑ p(bj,ck)
j=1 j=1
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)] por definición
j=1 i =1
s r t
=∑ ∑ p(ai,bj) · log[1/p(ai/bj)] · ∑ p(ck/bj) por iv)
j=1 i =1 k =1
s r t
=∑ ∑ ∑ p(ai,bj) · log[1/p(ai/bj)] · p(ck/bj) propiedades de sumatoria
j=1 i =1 k =1
s r t
=∑ ∑ ∑ p(ck/bj) · p(ai,bj) · log[1/p(ai/bj)] conmutatividad
j=1 i =1 k =1
s r t
=∑ ∑ ∑ p(ck/ai,bj) · p(ai,bj) · log[1/p(ai/bj)] por i)
j=1 i =1 k =1
s r t
=∑ ∑ ∑ p(ai,bj,ck) · log[1/p(ai/bj)] evidente
j=1 i =1 k =1
s t r
=∑ ∑ ∑ p(ai,bj,ck) · log[1/p(ai/bj)] propiedades de sumatoria
j=1 k =1 i =1
89
t r
H(A/C) = ∑ p(ck) · ∑ p(ai/ck) · log[1/p(ai/ck)] por definición
k =1 i =1
t r s
= ∑ p(ck) · ∑ ∑ p(ai/bj) · p(bj/ck) · log[1/p(ai/ck)] por vi)
k =1 i =1 j=1
t s r
=∑ ∑ ∑ p(ck) · p(ai/bj) · p(bj/ck) · log[1/p(ai/ck)] prop. de sumatoria
k =1 j=1 i =1
t s r
=∑ ∑ ∑ p(ai/bj) · p(bj/ck) · p(ck) · log[1/p(ai/ck)] conmutatividad
k =1 j=1 i =1
t s r
=∑ ∑ ∑ p(ai/bj,ck) · p(bj/ck) · p(ck) · log[1/p(ai/ck)] por ii)
k =1 j=1 i =1
t s r
=∑ ∑ ∑ p(ai/bj,ck) · p(bj,ck) · log[1/p(ai/ck)] evidente
k =1 j=1 i =1
t s r
=∑ ∑ ∑ p(ai,bj,ck) · log[1/p(ai/ck)] evidente
k =1 j=1 i =1
s t r
=∑ ∑ ∑ p(ai,bj,ck) · log[1/p(ai/ck)] propiedades de sumatoria
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/ck)]
j=1 k =1 i =1 j=1 k =1 i =1
s t r
=∑ ∑ ∑ p(ai,bj,ck) · log[1/p(ai/bj)] - p(ai,bj,ck) · log[1/p(ai/ck)] prop. sumatoria
j=1 k =1 i =1
s t r
=∑ ∑ ∑ p(ai,bj,ck) · {log[1/p(ai/bj)] - log[1/p(ai/ck)]} sale p(ai,bj,ck)
j=1 k =1 i =1
s t r
=∑ ∑ ∑ p(ai,bj,ck) · {log[1/p(ai/bj) / 1/p(ai/ck)]} log a - log b = log a/b
j=1 k =1 i =1
s t r
=∑ ∑ ∑ p(ai,bj,ck) · log[p(ai/ck) / p(ai/bj)] medios con medios, etc.
j=1 k =1 i =1
s t r
=∑ ∑ ∑ p(ai/bj,ck) · p(bj,ck) · log[p(ai/ck) / p(ai/bj)] evidente
j=1 k =1 i =1
s t r
=∑ ∑ p(bj,ck) · ∑ p(ai/bj,ck) · log[p(ai/ck) / p(ai/bj)] obvio
j=1 k =1 i =1
s t r
=∑ ∑ p(bj,ck) · ∑ p(ai/bj) · log[p(ai/ck) / p(ai/bj)] por ii)
j=1 k =1 i =1
s t r
= 1/ln(V) · ∑ ∑ p(bj,ck) · ∑ p(ai/bj) · ln[p(ai/ck) / p(ai/bj)] evidente
j=1 k =1 i =1
90
s t r
≤ 1/ln(V) · ∑ ∑ p(bj,ck) · ∑ p(ai/bj) · [p(ai/ck) / p(ai/bj) - 1] pues ln(z) ≤ z -1
j=1 k =1 i =1
s t r
= 1/ln(V) · ∑ ∑ p(bj,ck) · ∑ [p(ai/ck) - p(ai/bj)] obvio
j=1 k =1 i =1
s t r r
= 1/ln(V) · ∑ ∑ p(bj,ck) · [ ∑ p(ai/ck) - ∑ p(ai/bj)] evidente
j=1 k =1 i =1 i =1
s t s t
= 1/ln(V) · ∑ ∑ p(bj,ck) · [1 -1] = 1/ln(V) · ∑ ∑ p(bj,ck) · 0 = 0
j=1 k =1 j=1 k =1
r r
El último paso es lícito si mostramos que ∑ p(ai/ck) = ∑ p(ai/bj) = 1
i =1 i =1
Lo que hacemos a continuación:
r
∑ p(ai/bj) = 1 se ha demostrado en la página 78
i =1
r r s
∑ p(ai/ck) = ∑ ∑ p(ai/bj) · p(bj/ck) por vi)
i =1 i =1 j=1
s r
=∑ ∑ p(ai/bj) · p(bj/ck) evidente
j=1 i =1
s r
= ∑ p(bj/ck) · ∑ p(ai/bj) p(bj/ck) es independiente de i
j=1 i =1
s
= ∑ p(bj/ck) · 1 demostrado en la página 78
j=1
s
= ∑ p(ck/bj)·p(bj) / p(ck) Bayes
j=1
s
= [1/p(ck)] · ∑ p(ck/bj)·p(bj) obvio
j=1
= [1/p(ck)] · p(ck) por v)
=1
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 p(a2) = 1/2
canal 1 canal 2
⎡0.9 0.1⎤ ⎡0.8 0.2⎤
A ⎢ 0.1 0.9⎥ 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 canal 2
⎡3 / 4 0 1 / 4 ⎤
⎡1 / 2 0 1 / 2⎤ ⎢ 0 1 0 ⎥ C
A ⎢1 / 3 1 / 3 1 / 3⎥ B ⎢ ⎥
⎣ ⎦ ⎢⎣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

A -->
segundo canal ---> C
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 t
4) H(A/ B,C) = ∑ ∑ p(bj,ck) · H(A/bj,ck)
j=1 k =1
s t r
=∑ ∑ p(bj,ck) · ∑ p(ai/bj,ck) · log[1/p(ai/bj,ck)] por definición
j=1 k =1 i =1
s t r
=∑ ∑ ∑ p(bj,ck) · p(ai/bj,ck) · log[1/p(ai/bj,ck)] obvio
j=1 k =1 i =1
r s t
=∑ ∑ ∑ p(ai/bj,ck) · p(bj,ck) · log[1/p(ai/bj,ck)] obvio
i =1 j=1 k =1
r s t
=∑ ∑ ∑ p(ai,bj,ck) · log[1/p(ai/bj,ck)] evidente
i =1 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) la suma de una fila es 1
i =1 j=1
r s
=∑ ∑ p(bj/ai) · p(ai) · log[1/p(ai)] evidente
i =1 j=1
r s
=∑ ∑ p(ai,bj) · log[1/p(ai)] evidente
i =1 j=1
r s t
=∑ ∑ p(ai,bj) · log[1/p(ai)] · ∑ p(ck/ai) la suma de una fila es 1
i =1 j=1 k =1
r s t
=∑ ∑ ∑ p(ck/ai) · p(ai,bj) · log[1/p(ai)] evidente
i =1 j=1 k =1
r s t
=∑ ∑ ∑ p(ck/ai,bj) · p(ai,bj) · log[1/p(ai)] por 1)
i =1 j=1 k =1
r s t
=∑ ∑ ∑ p(ai,bj,ck) · log[1/p(ai)] evidente
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 s t
I(A; B,C) = ∑ ∑ ∑ p(ai,bj,ck) · log[1/p(ai)]
i =1 j=1 k =1
r s t
- ∑ ∑ ∑ p(ai,bj,ck) · log[1/p(ai/bj,ck)]
i =1 j=1 k =1
r s t
=∑ ∑ ∑ { p(ai,bj,ck) · log[1/p(ai)] - p(ai,bj,ck) · log[1/p(ai/bj,ck)] } obvio
i =1 j=1 k =1
r s t
=∑ ∑ ∑ p(ai,bj,ck) · {log[1/p(ai)] - log[1/p(ai/bj,ck)]} obvio
i =1 j=1 k =1
r s t
=∑ ∑ ∑ p(ai,bj,ck) · log[ 1/p(ai) / 1/p(ai/bj,ck) ] logaritmos
i =1 j=1 k =1
r s t
=∑ ∑ ∑ p(ai,bj,ck) · log[p(ai/bj,ck) / p(ai)] medios, etc.
i =1 j=1 k =1
r s t
=∑ ∑ ∑ p(ai,bj,ck) · log[p(ai/bj,ck)·p(bj,ck) / p(ai)·p(bj,ck)] obvio
i =1 j=1 k =1
r s t
=∑ ∑ ∑ p(ai,bj,ck) · log[p(ai,bj,ck) / p(ai)·p(bj,ck)] evidente
i =1 j=1 k =1
94
Resumiendo:
r s t
I(A; B,C) = ∑ ∑ ∑ p(ai,bj,ck) · log[p(ai,bj,ck) / p(ai)·p(bj,ck)]
i =1 j=1 k =1
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(a2) = p(1) = 1/2
b1 b2
a1 p q
P= a2 q p
donde q = 1-p
c1 c2
= a1 p q
a2 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 bj ck p(ai) p(bj,ck) p(ai,bj,ck)

0 0 0 1/2 (p2+q2) / 2 p2/2
0 0 1 1/2 p·q (p·q) / 2
0 1 0 1/2 p·q (p·q) / 2
0 1 1 1/2 (p +q2) / 2
2
q2/2
1 0 0 1/2 (p2+q2) / 2 q2/2
1 0 1 1/2 p·q (p·q) / 2
1 1 0 1/2 p·q (p·q) / 2
1 1 1 1/2 (p2+q2) / 2 p2/2
I(A; B,C) = p2 · log (2·p2 / p2+q2) + q2 · log (2·q2 / p2+q2)
96
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 b1 c2
a2 b2 c2
a3 --> ingresa al canal P --> b3 --> "segundo canal" --> c3= b3
... ... ...
ar bs 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 Matriz del segundo canal
c2 c3 ... cs
b1 ... bs b1 1
a1 b2 1
P= ... p(bj/ai) P2 = b3 1
ar ... ...
bs 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) sea 0 es necesario que haya una columna de
i =1
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) columna k de sólo ceros, salvo si (k=j): p(ck/bk)=1
= p(ai/bk) p(ck)=p(bk)
El último paso utiliza el hecho de que -con la segunda matriz-

s
p(ck) = ∑ p(ck/bj) · p(bj)
j=1
= p(ck/bk) · p(bk) columna k de sólo ceros, salvo si (k=j): p(ck/bk)=1
= p(bk)
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(ai) = 1/2
b1 b2 b3
P= a1 1/8 1/4 5/8
a2 1/4 1/2 1/4
Sea P' una reducción elemental de P
c2 c3=b3
P' = a1 3/8 5/8
a2 3/4 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 }
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
En efecto, por definición H(B/A) = ∑ p(ai) · ∑ p(bj/ai) · log[1/p(bj/ai)]
i =1 j=1
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
H(B/A) = ∑ p(ai) · k = k · ∑ p(ai) = k · 1 = k es decir,
i =1 i =1
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) cálculo de p(bj)
i =1
r
= ∑ p(bj/ai) · 1/r tomando p(ai)=1/r
i =1
r
= 1/r · ∑ p(bj/ai) obvio
i =1
= 1/r · c canal débilmente simétrico, columnas suman c
= c/r
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
b1 b2
P= a1 p q donde q = 1-p
a2 q 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)] (para algún i)
j=1
= 1 - [ p·log(1/p) + q·log(1/q)] 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
calcular p(bj) utilizando p(bj)= ∑ p(bj/ai)·p(ai)
i =1
REPETIR hasta una estimación aceptable

s
calcular fi = exp{ ∑ p(bj/ai)·ln[p(bj/ai)/p(bj)] } exp es la función exponencial
j=1
r
x= ∑ fi · p(ai)
i =1
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
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,
PE = 1 - PC s s
PE = ∑ [1-p(a*/bj)]·p(bj) = ∑ [p(bj)-p(a*/bj)·p(bj)]
j=1 j=1
s s
= ∑ p(bj)- ∑ p(a*/bj)·p(bj)
j=1 j=1
s
= 1 - ∑ p(a*/bj)·p(bj)
s
= 1 - ∑ p(a*/bj)·p(bj)
j=1 j=1
r s s r
como ∑ ∑ p(ai,bj) = ∑ ∑ p(ai,bj) =1
i =1 j=1 j=1 i =1
s r s s r s
PE = ∑ ∑ p(ai,bj) - ∑ p(a*/bj)·p(bj) = ∑ ∑ p(ai,bj) - ∑ p(a*,bj)
j=1 i =1 j=1 j=1 i =1 j=1
(algunos autores lo escriben así) = ∑ ∑ p(ai,bj)
B 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 r s
PE = ∑ ∑ p(ai,bj) - ∑ p(a*,bj) = 0.3 + 0.2 + 0.2 + 0.3 - [0.3 + 0.3] = 0.4
j=1 i =1 j=1
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:
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.
⎡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/a1) = 0.5

p(b1/a2)·p(a2) = 0.5·1/2 = 0.25 p(b1/a2) = 0.5
Es claro que la condición Es claro que la condición
∀ai p(b1/a1)·p(a1) ≥ p(b1/ai)·p(ai) se cumple ∀ai p(b1/a1) ≥ p(b1/ai) se cumple
y ∀ai p(b1/a2)·p(a2) ≥ p(b1/ai)·p(ai) también y ∀ai p(b1/a2) ≥ p(b1/ai) también
Luego, a b1 se le puede asignar tanto a1 como a2. Luego, a b1 se le puede asignar tanto a1
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 r s
Y sabiendo que: PE = ∑ ∑ p(ai,bj) - ∑ p(a*,bj)
j=1 i =1 j=1
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.

⎡ 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
Luego, D(b1) = a1
b2) Como: p(b2/a1) = q
p(b2/a2) = p
p>q
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 r s
PE = ∑ ∑ p(ai,bj) - ∑ p(a*,bj) = p/2 + q/2 + q/2 + p/2 - [p/2 + p/2] = q
j=1 i =1 j=1
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
Así pues: 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 p2 q p2q pq2 pq2 pq2 q3
a2=111 q3 pq2 pq2 pq2 p2 q p2q p2q p3
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
Luego, D(b1) = a1
b2) Como: p(b2/a1) = p2q
p(b2/a2) = pq2
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(a2,b1) = p(b1/a2)·p(a2) = q3·1/2 = q3/2
p(a1,b2) = p(b2/a1)·p(a1) = p2q·1/2 = p2q/2 p(a2,b2) = p(b2/a2)·p(a2) = pq2·1/2 = pq2/2
p(a1,b3) = p(b3/a1)·p(a1) = p2q·1/2 = p2q/2 p(a2,b3) = p(b3/a2)·p(a2) = pq2·1/2 = pq2/2
p(a1,b4) = p(b4/a1)·p(a1) = p2q ·1/2 = p2q/2 p(a2,b4) = p(b4/a2)·p(a2) = pq2·1/2 = pq2/2
p(a1,b5) = p(b5/a1)·p(a1) = pq2·1/2 = pq2/2 p(a2,b5) = p(b5/a2)·p(a2) = p2q·1/2 = p2q/2
p(a1,b6) = p(b6/a1)·p(a1) = pq2·1/2 = pq2/2 p(a2,b6) = p(b6/a2)·p(a2) = p2q·1/2 = p2q/2
p(a1,b7) = p(b7/a1)·p(a1) = pq2·1/2 = pq2/2 p(a2,b7) = p(b7/a2)·p(a2) = p2q ·1/2 = p2q/2
p(a1,b8) = p(b8/a1)·p(a1) = q3·1/2 = q3/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 r s
PE = ∑ ∑ p(ai,bj) - ∑ p(a*,bj) = 3pq2/2 + q3/2 + q3/2 + 3pq2/2 = 3pq2 + q3
j=1 i =1 j=1
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
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)
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<C.
Así pues, con el propósito de ganar confiabilidad, un canal puede utilizarse de manera más
ingeniosa mediante algunas modificaciones.
A esta manipulación la llamaremos más adelante construcción de códigos (del) canal.
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<C, tal que el principio
de decodificación de máxima posibilidad nos da un error de la regla de decisión PE<δ.
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)
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:
Luego, 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*).
¿ Pará cual 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 s1s1s1s3s1s3 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 pre-
entradas 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, pues en ese caso dC'<dC.
Es decir, ∀ai 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
PE = 1 - ∑ p(a*/bj)·p(bj) = (por Bayes) = 1 - ∑ p(bj/a*)·p(a*)
j=1 j=1
Misma que se minimiza haciendo máxima la sumatoria. Pero precisamente ese es el
principio del mínimo error:
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<C) y
minimizando la probabilidad de error (por ejemplo eligiendo la menor cantidad de
palabras código muy distantes entre sí –quizás con un N grande-).
Código perfecto.- Partamos de un ejemplo. Sea k=1 y sea C={a1,a2}={0000,1111}.

Es decir, en el código de repetición se han añadido 3 bits de redundancia para tener N=4.
Es claro que dC=4, luego C puede corregir hasta t = 1 error.
Por ejemplo si b=0010, como 1=d(a1,b)<d(a2,b)=3 y no hay más palabras código, se
corrige b y se decide que se ha enviado a1.
Sin embargo si b=0110, d(a1,b)=d(a2,b)=2. Es decir, el código C no sabe cómo corregir
algunas secuencias de salida, sólo puede detectar la presencia de errores.
Además de tener la mayor cantidad de palabras, puede ser deseable que un código sea
construido de tal forma que corrija todos los(hasta t) errores, es decir, que todas las
secuencias de salida sean: o bien una palabra código, o bien una palabra código con hasta t
bits errados. Como queremos que C corrija hasta t errores ninguna salida b estará igual de
distante de más de una palabra código (como en el ejemplo). Es decir, queremos un código
que sepa qué hacer exactamente con cada salida.
El código canal C de longitud N que corrige hasta t errores se dice perfecto si es maximal
y ∀b ∃!ai d(ai,b) ≤ t (∃! se lee existe un único).
Otra forma de decirlo es que C es perfecto cuando (además de ser maximal) todas las
palabras (que salen del canal) que tengan hasta t errores son corregidas.
Recordemos (límite de Hamming) que 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). Y que
como sólo hay 2N secuencias posibles resulta que: M·V(N,t) ≤ 2N. Pero entonces, la
definición de código perfecto implica (que se alcanza) la igualdad en el límite de
Hamming (en 2N no hay salidas b tales que no sepamos qué hacer con ellas).
De hecho hay quienes definen un código perfecto como aquel que satisface la igualdad en
el límite de Hamming.
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,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
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 log2[V(N,1)] r log2[V(N,2)]
3 2 1 2.80735492
4 2.32192809 2 3.45943162
5 2.5849625 3 4
6 2.80735492 4 4.45943162
7 3 5 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 pre-
entradas 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-:
V(N,1) ≤ 2r -que expandiendo V(N,1) se convierte en-:
1 ⎛ N⎞
∑ ⎜⎜ i ⎟⎟ ≤ 2r -que expandiendo la sumatoria se convierte en-:
i =0 ⎝ ⎠
N + 1 ≤ 2r -que con N=k+r se convierte en-:
k+r+1≤2 r
-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 los 4 bits de las pre-entradas. Los renombraremos así:
p4 p3 p2 p1
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: a 7 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
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 código de pre-entradas código de
Hamming Hamming
C C
0000 0000000 1000 1001011
0001 0000111 1001 1001100
0010 0011001 1010 1010010
0011 0011110 1011 1010101
0100 0101010 1100 1100001
0101 0101101 1101 1100110
0110 0110011 1110 1111000
0111 0110100 1111 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(2,2) = -1 H(1,1) = H(1,2) = H(2,1) = 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 1 1 0 1
[0 0]·  = [0 0 0] [0 1]·  = [0 1 1]
0 1 1 0 1 1
1 0 1 1 0 1
[1 0]·  = [1 0 1] [1 1]·  = [1 1 0]
0 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, utilizamo 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 
C1 =   permutando las filas 1 y 4 :   sumando la fila 1 a la 2:
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, se entiende que 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 todos 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) donde 0k × (N- k) representa una matriz de ceros.

H·GT = 0(N-k) × k 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.

 u1 1 0 a11 ... a1(N - k ) 
  
Sea G =  ...  = [ Ik × k : Ak × N-k ] =  ... ... ... ... 
uk  0 1 ak 1 ... ak (N - k ) 
136
 v1   a11 ak 1 1 0
Luego H =  ...  = [ AT : I(N- k) × (N- k) ] =  ... ... 
 vN - k  a1(N - 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 ] · I(N- k) × (N- k) operaciones sobre matrices
= [ (Ik × k · A) + (Ak × N-k · I(N- k) × (N- k))] operaciones sobre matrices

= [ A + A] operaciones sobre matrices
= 0k × (N-k) 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
conmutando y asociando, es decir,
reordenando con respectoa los ai
= a1(v1g11 + v2g12+…+ vNg1N)
+ a2(v1g21 + v2g22+…+ vNg2N)
…
+ ak(v1gk1 + v2gk2+…+ vNgkN)
=0 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) (*)
  
r1 a 11 a k 1 1 0 
 
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:
⎡1 0 a11 ... a1(N - k ) ⎤
T ⎢
T
G·z = [ Ik × k : Ak × N-k ]·z = ⎢ ... ... ... ... ⎥⎥ ·[z1z2 ... zk 0 ... 0]T
⎣⎢0 1 ak 1 ... ak (N - k ) ⎦⎥
= [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 =  ...  =  ... ... ...  la matriz generadora de C
uk  gk 1 ... gk N 
 r1  g11 ... g1N g11+...+ g1N 
Entonces Ge = ... =  ... ... ... ...  es la matriz generadora de C .
 e
rk  gk 1 ... gk N 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 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)<d(v,wj)
Como d(v,wj)=peso(v+wj) y d(v,wh)=peso(v+wh), resulta que:
peso(v+wh) < peso(v+wj)
Como -por (*)- peso(v+wj)=peso(vi), tenemos: peso(v+wh) < peso(vi)
Además v+wh = vi + wj + wh = vi + wñ puesi v=vi + wj y por la linealidad de C
Es decir, v+wh (= vi + wñ) está –por construcción- en la fila i (o, lo que es lo mismo, por
definición v+wh está en el co-conjunto vi + C).
Esto contradice el hecho de que vi sea el líder de la fila i. El resultado sigue.
El algoritmo de decodificación es evidente:

Al recibir v, buscamos dicha palabra en la matriz. Y decidimos que se ha enviado wj, la
palabra código que está al principio de la columna j (en la primera fila).
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 (b)
Demostración:
v,v' ∈ 2N están en el mismo co-conjunto (donde u+C es el co-conjunto donde está v)
si y sólo si por definición de co-conjunto
v = u + wi
v' = u + wj
si y sólo si obvio
u = v + wi
u = v' + wj
si y sólo si obvio
v + wi = v' + wj
si y sólo si obvio
v + v' = wi + wj
si y sólo si linealidad de C y (a); donde wñ=(wi+wj) ∈ C
v + v' = wñ
si y sólo si obvio
v + v' ∈ C
144
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 por (b)
(v+v') ∈ C
si y sólo si resultado demostrado en el subtítulo síndrome
(v+v')·HT = 0
si y sólo si propiedades de matrices
(v·HT + v'·HT) = 0
si y sólo si obvio
v·HT = v'·HT
si y sólo si definición de síndrome y supuestos
s = s'
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:
⎡1 1 0 0⎤
Sea C = { 0000, 1111 } con G =[ 1 1 1 1 ] H = ⎢⎢1 0 1 0⎥⎥ dC=4
⎢⎣1 0 0 1⎥⎦
145
Tabla de líderes Tabla de síndromes
0000 000
1000 111
0100 100
0010 010
0001 001
1100 101
1010 101
1001 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 :
⎡ h11 ... h1N ⎤
Sea w=w1w2...wN y sea H = ⎢⎢ ... ... ... ⎥⎥ = [columna1 ··· columnaN]
⎢⎣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 1 0 1 0 0 1⎤
⎢0 1 0 1 0 1 0⎥⎥
El resultado es: G = ⎢
⎢1 1 1 0 0 0 0⎥
⎢ ⎥
⎣1 0 0 1 1 0 0⎦
Cuyo código con dC=3 es el siguiente:

pre-entrada palabra código pre-entrada palabra código
0000 0000000 1000 1101001
0001 1001100 1001 0100101
0010 1110000 1010 0011001
0011 0111100 1011 1010101
0100 0101010 1100 1000011
0101 1100110 1101 0001111
0110 1011010 1110 0110011
0111 0010110 1111 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 ⎤
⎢... ... ... ...⎥
H =⎢ ⎥ La suma (módulo 2) de cualquier par de columnas devuelve otra.
⎢ 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] · ⎢⎢ ... ...
T
... ⎥⎥ = [h1j h2j ... h(N-k)j] = cjT
⎢⎣h1N ... h(N - k )N ⎥⎦
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
= w·HT + e·HT 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 Secuencia de ceros

junto a junto a
Palabra(s) e de peso 1 Columna(s) j de H
(e tiene ceros excepto un 1 en la posición j)
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 ⎥
Código dual de un código de Hamming.- Para G = ⎢ ⎥ cuyo código
⎢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 ⎥
Para G = ⎢ ⎥ cuyo código de Hamming correspondiente C, con
⎢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.
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 }

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 Polinomios asociados
000 0
101 1 + x2
011 x + x2
110 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
N
2) x × b(x) = x · b(x) mod (x + 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 Considerando Cp
000 0
101 1 + x2
011 x + x2
110 1+x
Una rotación de 110 es: x · [1 + x] mod (x3 + 1)

= x + x2 mod (x3 + 1)
011 = x + x2
Una rotación de 011 es: x · [x + x2] mod (x3 + 1)

= x2 + x3 mod (x3 + 1)
101 = 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) }
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.
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 = <g(x)>
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
a0[g(x) mod (xN + 1)] + a1[x·g(x) mod (xN + 1)] +...+ ak-1[xk-1 ·g(x) mod (xN + 1)] = 0
[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 g1 ... gr 0 0 ... 0 ⎤ ⎡ g(x) ⎤

⎢0 g0 g1 ... gr 0 ... 0 ⎥⎥ ⎢ x·g(x) ⎥
⎢ ⎢ ⎥
G = ⎢ ... ... ... ... ... ... ... ...⎥ ≅ ⎢ x 2 ·g(x) ⎥
⎢ ⎥ ⎢ ⎥
⎢0 ... 0 g0 g1 ... gr 0 ⎥ ⎢ ... ⎥
⎢⎣ 0 ... 0 0 g0 ... gr -1 gr ⎥⎦ ⎢⎣ 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 Cp Nótese que
000 0 0 = 0 · g(x)
101 1 + x2 2
1 + x = (1 + x) · g(x)
011 x + x2 x + x2 = x · g(x)
110 1+x 1+x = 1 · g(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))<gr(g(x)).
Por los resultados 1 y 4, b(x) es el polinomio generador de Sp.
Se sabe que g’(x) es un factor de (xN + 1): g’(x) · t(x) = (xN + 1) donde gr(t(x))=N-r.
Como b(x)∈Sp, entonces b(x) = g’(x) × q(x) = q(x) × g’(x)
Luego:
[b(x) × t(x)] = [q(x) × g’(x) × t(x)] pues b(x) = q(x)×g’(x)
= [q(x) × [g’(x) × t(x)]] asociatividad de ×, Anexo 4
= [q(x) × [g’(x) · t(x) mod (xN + 1)]] definición de ×
= [q(x) × [(xN + 1) mod (xN + 1)]] g’(x) · t(x) = (xN + 1)
= [q(x) × [ 0 ]] obvio
= [q(x) · 0 mod (xN + 1)] definición de ×
=0 obvio
Pero 0<gr(b(x)·t(x))<gr(g’(x)·t(x)) = N, luego es absurdo que [b(x) × t(x)] = 0.
Luego, el supuesto es erróneo y g(x)=b(x) es el polinomio de grado mínimo en Sp.
Por los resultados 1 y 4, es el polinomio generador de Sp.
Sea C el conjunto de palabras código asociadas a los polinomios de Sp.
En la tercera página de este capítulo, probamos que:
Si Sp es un ideal Entonces el código C es cíclico.
Luego C es un código cíclico.
g’(x) es el polinomio generador de Sp y la matriz generadora de C se puede construir a
partir de g’(x) como en el inciso 8).
Los resultados 1 a 8 nos brindan, dado un código cíclico C, un nuevo modo de enfocarlos.
Y, por ejemplo, una otra manera de obtener su matriz generadora C.
El resultado 9, por otro lado, nos permite obtener códigos cíclicos de longitud N,
factorizando (xN + 1).
Ejemplo:
Para N=3 (x3 + 1) = (1+x) · (1 + x + x2)
Para g(x) = (1 + x + x2), G = [1 1 1] que genera el código cíclico C = { 000, 111 }.
⎡1 1 0 ⎤
Para g(x) = (1 + x), G = ⎢ ⎥ que genera el código cíclico C = {000, 011, 110, 101}.
⎣0 1 1 ⎦
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 de 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 matrices en el código C Trabajando con polinomios en Cp
Dado C obtenemos la matriz generadora G Dado Cp obtenemos el polinomio generador

así: g(x) así:
Las palabras de C son las filas de una
matriz. Se halla la forma escalonada de C, Elegimos el polinomio de menor grado
mediante operaciones elementales sobre como g(x).
filas (Gauss) y recogiendo sólo las filas
diferentes de cero.
162
Dada la matriz G se obtiene su matriz de Dado el polinomio g(x) se obtiene su

paridad H, así: polinomio de paridad h(x), así:
Obtenga la forma canónica Gc=[ I : A ] de Como g(x) divide a (xN + 1), entonces
G, luego Hc=[ AT : I ] y luego H aplicando (xN + 1) = g(x) · h(x)
en orden inverso las permutaciones de Es decir, h(x) = (xN + 1) / g(x).
columnas.
El código dual C┴ se obtiene a partir de su El ideal dual Cp┴ se obtiene a partir de su

matriz generadora H, que es la matriz de polinomio generador hR(x), llamado el
paridad de G. polinomio recíproco de h(x):
hR(x) = xk · h(1/x)
Dada la matriz Gk × N generar el código C Dado el polinomio g(x) con gr(g(x))= r =N-k
así: generar Cp así:
[a1 … ak]·G donde a1...ak a(x)·g(x) con gr(a(x))<k

es una secuencia de longitud k
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: x ·g(1/x)·xk·h(1/x) = (xN+1).
r
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 ... 0 hk hk -1 ... h0 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 (con w ∈ C, por definición).

Sabemos también que g(x)×h(x) = 0.
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 contruir 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.
Codificación sistemática. Codificación sistemática.

Se contruyen las palabras código en forma Dado v(x), se obtiene su polinomio
sitemática, mediante su matriz generadora sistemático así:
Gc = [ A : I ], a partir de la matriz
generadora G mediante operaciones w(x) = [v(x)·xr mod g(x)] + v(x)·xr
elementales de filas y columnas.
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 Supondremos que se trabaja con

sistemáticos. codificación sistemática.
El síndrome de la cadena w es: El síndrome de w(x) es:
s = w·HT 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))<r
Demostración:
Es claro que xr+i = q(x)·g(x)+Ai(x), es decir, Ai(x) + xr+i = qi(x)·g(x)
Como q(x)·g(x)∈Cp, {Ai(x) + xr+i / 0 ≤ i ≤ k-1} es un conjunto de k elementos de Cp.
Probaremos ahora que estos k elementos son linealmente independientes.
La ecuación b0[A0(x) + xr] + ... + bk-1[Ak-1(x) + xr+k-1] = 0, se puede reescribir así:
[b0A0(x) +...+ bk-1Ak-1(x)] + [b0xr +...+ bk-1xr+k-1] = 0
Como gr(Ai(x))<r, ningún sumando del primer corchete influye en el segundo.
Es claro que los exponentes de los sumandos del segundo corchete son
consecutivos desde r hasta r+k-1, es evidente que la única solución se da para bi=0.
Eso muestra que {Ai(x) + xr+i / 0 ≤ i ≤ k-1} es un conjunto de k elementos
linealmente independientes.
Al ser k la dimensión de Cp, una de sus bases es este conjunto.
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 ... a0(r-1) 1 0 ... 0 ] [ A0(x) + xr ]

[ a10 a11 ... a1(r-1) 0 1 ... 0 ] [ ]
...
G= [ ... ] ≅ [ ]
r+k-1
[ a(k-1)0 a(k-1)1 ... a(k-1)(r-1) 0 ... 0 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)
168
Es decir:
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))<r, es evidente que gr(s(x))<r, por lo tanto:
s(x) = w(x) mod g(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
⎡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
G·HRT = ⎢⎢0 1 0 1 1 1 0⎥⎥ · ⎢ ⎥ = ⎢0 0 0 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, 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 son 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] ) derivando (+ regla de la cadena)

x −> 0
= lim ( [- 1/x] / [ - 1/x2] ) obvio

x −> 0
= lim ( x ) obvio
x −> 0
=0
Así pues,
lim pi · logr (1/pi ) = [1/ ln(r)] · [ lim pi · ln(1/pi ) ] pues logr z = (loge z / loge r)
pi − > 0 pi − > 0
= [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 Kx > 0

Sabemos que l>0
Luego, como ∀x>0 Kx ≤ x·l resulta

∀x>0 (1 / l) ≤ (x / Kx)
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 donde

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.
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 RA=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×b1i, …, 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×b1ij+...+ ak×b1j, …, 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 co-
conjunto). 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 co-
conjunto. 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 ×
= p(x) · [q(x) · t(x) – k(x) · (xN + 1)] mod (xN + 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
= [p(x) · q(x) · t(x) – k’(x) · (xN + 1) · t(x) ] mod (xN + 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)
= [p(x) · q(x) mod (xN + 1) ] · t(x) mod (xN + 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 extensión de la Fuente-M, 19

algoritmos de decodificación, 142 extensión de orden n de una fuente de
arreglo estándar, 142 información de memoria nula, 9
Blahut-Arimoto, 102 forma canónica, 134
bloque, 22 fuente afín o adjunta, 18
canal binario borrador, 87 fuente de memoria nula, 6
canal binario simétrico (BSC), 86 fuente equiprobable, 6
canal débilmente simétrico, 86 fuente reducida, 64
canal simétrico, 86 fuente regular y ergódica, 15
canales ambiguos, 85 Gibbs, 48
canales de información con ruido, 71 ideal, 155
canales determinantes, 84 información mutua, 73
canales sin ruido, 83 instantáneo, 26
cantidad de información, 6 L(C), 54
Chapman-Kolmogorov, 14 libre de prefijos, 23
co-conjunto, 142 líder, 142
codificación aritmética, 68 límite de Gilbert-Varshamov, 122
codificación sistemática, 166 límite de Hamming, 119
código dual, 134 longitud media de un código, 54
código equivalente, 133 matriz de (testeo de) paridad, 135
código extendido o expandido, 141 matriz típica, 142
código lineal, 130 mellizas, 57
código maximal, 120 Nguyen Hung Vu, 34
código perfecto, 121 no-singular, 22
códigos (del) canal, 115 patrón de error, 142
códigos cíclicos, 154 Patterson y Sardinas, 24
códigos de fano, 62 Perron-Frobenius, 14
códigos de Hadamard, 127 peso de una palabra código, 132
códigos de Hamming, 125 polinomio generador, 158
códigos de Huffman, 63 principios de decodificación, 103
códigos de paridad, 124 reducción elemental, 97
códigos de Shannon, 62 reducción suficiente, 98
compacto, 54 redundancia, 59
cota de Singleton, 147 shannon, 61, 107
distribución estacionaria, 13 síndrome, 140, 166
dual, 163 singular, 22
eficiencia, 59 sistema de entropías, 73
entropía, 7 tabla de síndromes, 145
equivocación del canal, 73 unívocamente decodificable, 24
estandarización de las entradas, 117 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 PDF

Загружено:

Сведения о документе

Исходное описание:

Оригинальное название

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

TeoriadelaInformacionylaCodificacion PDF

Загружено:

Авторское право:

Доступные форматы

INSTITUTO DE INVESTIGACIONES EN 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

CAPÍTULO 1: FUENTES DE INFORMACIÓN Y ENTROPÍA

CAPÍTULO 2: INTRODUCCIÓN A LOS CÓDIGOS

CAPÍTULO 3: CÓDIGOS Y FUENTES DE INFORMACIÓN. PROPIEDADES

CAPÍTULO 4: CODIFICACIÓN DE FUENTES

CAPÍTULO 6: CÓDIGOS CANAL

CAPÍTULO 8: CÓDIGOS CÍCLICOS........................................................................ 154

ANEXO 1 (Demostración de " lim pi · logr (1/pi ) = 0" ).............................................. 172

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

Este trabajo tiene la pretensión de presentar la Teoría de la Información y la Codificación

Resta agradecer a la Universidad Mayor de San Andrés, a la Facultad de Ciencias Puras y

Los desaciertos son mi responsabilidad: me adelanto en agradecer a quienes hagan

Fuente-S = (S,Ω) donde:

De la definición de distribución de probabilidades está claro que:

Usualmente se representa en una tabla así: Ejemplo concreto de una Fuente-S:

En una Fuente-S de memoria nula la aparición/emisión de un símbolo es independiente de

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:

Aunque hubieron algunas propuestas más, se ha aceptado la siguiente definición:

Es claro que cuando pi = 1, I(si) = logr 1/1 = logr 1 = 0 r-its

Es claro que cuando pi = 1, pi · logr (1/pi ) = 1 · log 1/1 = 1 · 0 = 0 r-its

Ejemplo: Calcularemos la entropía en nats para la Fuente-S:

Dado que logv z = (logr z / logr v), entonces:

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

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

= (1/ln 2) · ( 1.28702157893) bits

La extensión de orden n de una fuente de información de memoria nula, denotada por

Sea la Fuente-S original representada así:

La Fuente-Sn (extensión de orden n de la Fuente-S) tiene como su

Ejemplo: Para la siguiente Fuente-S de memoria nula original:

Su extensión de orden n=2 es la siguiente Fuente-S2 también de memoria nula:

En el caso de estas fuentes extendidas indicaremos -sin demostración- que las

Ejemplo: Sea la siguiente fuente de Markov de orden 2. S={0,1} q=2 m=2

00 01 10 11 Nótese que las columnas deben sumar 1.

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

El cálculo de la entropía de una fuente de Markov es semejante al cálculo de la entropía en

En principio se define la entropía de la Fuente-M en el estado "sj1sj2 ... sjm" como:

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

Donde el orden es m=2, S={0,1}, q=2

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

H2(S/α1) = H2(S/00) = 0.72192 bits

Distribución estacionaria.- Recordemos que W(0) = [ w1(0), ... , wqm(0) ]T es la distribución

La entropía de una Fuente-M se define así:

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

La solución en nuestro caso es:

Finalmente H2(M) = 0.80137 bits

Recordemos que se llama distribución estacionaria a la solución del sistema

Cuando la Fuente-M es regular su distribución límite existe y coincide con la distribución

Cuando centramos los conceptos considerando el grafo de la Fuente-M, hay un modo de

Una Fuente-M es ergódica cuando es irreducible: hay un camino de un estado a otro

Una fuente-M es regular cuando se cumplen las tres siguientes condiciones:

No es irreducible: no podemos ir de α1 a α3 por ejemplo. Luego, no es ergódica.