FAMAT em Revista - Número 06 - Maio de 2006 75

CÓDIGOS CORRETORES DE ERROS LINEARES*

Marcos Antônio da Câmara† Adenilce Oliveira Souza

Universidade Federal de Uberlândia

Av. João Naves de Ávila, 2160
Campus Santa Mônica
38408-100 – Uberlândia – MG
Faculdade de Matemática
VII Curso de Especialização em Matemática

RESUMO

Neste trabalho apresentamos uma introdução à teoria dos Códigos Corretores de Erros, que é uma parte
da matemática aplicada usada na área de transmissão de informação e que necessita fortemente de
conceitos e resultados da matemática pura, especialmente da álgebra. Falaremos especificamente de uma
classe de códigos corretores de erros, os códigos lineares.
Palavras Chave: Código linear, matriz geradora, decodificação

INTRODUÇÃO

A história dos Códigos Corretores de Erros começa em 1948 com a publicação

de um artigo pelo matemático e engenheiro Claude E. Shannon, do laboratório Bell.
Inicialmente uns dos maiores interessados nesta teoria foram os matemáticos que a
desenvolveram consideravelmente nas décadas de 50 e de 60. A partir da década de 70,
com as pesquisas espaciais e a grande popularização dos computadores, essa teoria
começou a interessar também aos engenheiros.
Hoje os códigos corretores de erros participam do nosso cotidiano de inúmeras
formas, estando presentes, por exemplo, sempre que fazemos uso de informações
digitalizadas, tais como assistir a um programa de televisão, falar ao telefone, ouvir um
CD de música, assistir a um filme em DVD, mandar um recado a alguém via Pager ou
navegar pela Internet.
Um problema geral pode ser assim exemplificado:

“Suponha que se deseja enviar uma mensagem por um canal de comunicação a cabo de
São Paulo para Uberlândia. Eventualmente esta mensagem pode sofrer interferências
no caminho. Por exemplo, se considerarmos uma mensagem binária (seqüências de 0’s
e 1’s), pode acontecer de um 0 enviado chegar ao destino como 1 ou vice-versa.”
___________________________________________
* Monografia apresentada por Adenilce Oliveira Souza à Faculdade de Matemática, como requisito
parcial para a obtenção do título de Especialista em Matemática.
† Professor orientador: camara@ufu.br

A teoria de códigos foi criada para tentar corrigir estes erros. Um código corretor
de erros é, em essência, um modo organizado de acrescentar algum dado adicional a
cada informação que se queira transmitir ou armazenar e que permita, ao recuperar a
informação, detectar e corrigir erros.
76 FAMAT em Revista - Número 06 - Maio de 2006

Devido ao fato de que a motivação primária para o desenvolvimento dos códigos

corretores de erros ser a resolução de problemas em comunicações, essa teoria foi
enquadrada na teoria das comunicações.
Aplicações em problemas de comunicações são diversificadas. Dados binários
são comumente transmitidos entre terminais de computadores, entre aeronaves e entre
espaçonaves. Códigos corretores de erros são usados freqüentemente em aplicações
militares para proteção contra interferência inimiga intencional.
As transmissões entre sistemas computacionais usualmente são intolerantes até
mesmo a baixas taxas de erros, porque um simples erro pode destruir um programa de
computador. Códigos corretores de erros tornam-se importantes nestas aplicações.
Podemos antecipar que técnicas de controle de erros representarão um papel
central em todos os sistemas de comunicação do futuro, pois o futuro é digital.
O presente trabalho constitui uma breve introdução à teoria dos códigos
corretores de erros.
No capítulo I desta monografia, apresentamos os elementos de um sistema de
comunicações e definimos alguns conceitos básicos para podermos iniciar a
compreensão de como funcionam os códigos corretores de erros.
No capítulo II, nos dedicamos a uma única classe de códigos, os códigos
lineares, determinamos os seus parâmetros e apresentamos os algoritmos gerais de
correção de erros.
No capítulo III, apresentamos um exemplo de código linear, onde usamos toda a
teoria estudada na monografia para mostrar como se codifica e se decodifica uma
mensagem.
FAMAT em Revista - Número 06 - Maio de 2006 77

CAPÍTULO I

CÓDIGOS CORRETORES DE ERROS

1.1 – Sistema de Comunicação

Um sistema de comunicações conecta uma fonte de dados a um usuário de dados

através de um canal.
O modelo do sistema de comunicações desenvolve dispositivos que preparam o
“input” e processam o “output” do canal.
Dados que entram no sistema de comunicações através de uma fonte de dados,
são inicialmente processados por um codificador da fonte projetado para representar os
dados da fonte de maneira mais compacta. Esta representação é uma seqüência de
símbolos chamada palavra código da fonte. Então, os dados são processados por um
codificador de canal, que transforma a seqüência de símbolos da palavra código da fonte
em outra seqüência chamada palavra código do canal.
A palavra código do canal é uma nova e longa seqüência que têm mais
redundância que a palavra código da fonte. Cada símbolo na palavra código do canal
pode ser representada por um bit ou, talvez, por um grupo de bits. Depois, o modulador
converte cada símbolo da palavra código do canal em um símbolo analógico
correspondente de um conjunto finito de símbolos analógicos possíveis.
A seqüência de símbolos analógicos é transmitida através do canal. Como o
canal está sujeito a vários tipos de ruídos, distorções e interferências, os dados que saem
do canal diferem dos dados que entram no canal. O demodulador converte cada sinal de
saída do canal recebido na seqüência correspondente de símbolos da palavra código do
canal. Cada símbolo demodulado é a melhor estimativa do símbolo transmitido, mas o
demodulador comete alguns erros devido a interferências do canal. A seqüência de
símbolos demodulada é chamada de palavra recebida. Devido aos erros, os símbolos da
palavra recebida nem sempre são iguais aos símbolos da palavra código do canal.
O decodificador do canal usa a redundância da palavra código do canal para
corrigir os erros da palavra recebida e então produzir uma estimativa da palavra código
fonte. Se todos os erros são corrigidos, a palavra código fonte estimada é igual à palavra
código fonte original. O decodificador da fonte executa a operação inversa do
codificador da fonte e envia sua saída para o usuário.
As funções compressão ou compactação de dados executadas pelo codificador
da fonte e o decodificador da fonte não serão discutidas neste trabalho, bem como o
modulador e o demodulador. Os codificador e decodificador de canal serão designados
daqui em diante, simplesmente, por codificador e decodificador, respectivamente.
78 FAMAT em Revista - Número 06 - Maio de 2006

Sistema de Comunicação

Fonte Codificador Decodificador Usuário

Da Fonte Da Fonte
Palavra Palavra código
código da da fonte
fonte estimada

Codificador Decodificador
Do Canal Do Canal
Palavra Palavra
código do recebida
canal
Demodulador
Modulador

Canal

1.2 – Conceitos Básicos

Suponha que todos os dados de interesse pudessem ser representados por uma
informação binária, isto é, como uma seqüência de zeros e uns. Esta informação binária
está para ser transmitida através de um canal que causa erros ocasionais. O propósito de
um código é adicionar símbolos extras aos símbolos da informação de modo que os
erros podem ser encontrados e corrigidos no receptor. Isto é, uma seqüência de símbolos
de dados é representada por uma seqüência maior de símbolos com redundância
suficiente para proteger os dados.
Um código binário de tamanho M e comprimento de bloco n é um conjunto de
k palavras de comprimento n, chamadas palavras do código. Geralmente M = 2k para
um inteiro k e o código é denominado de código binário (n,k)
Por exemplo, nós podemos fazer o seguinte código:

00000
01011
 
C= 
10110 
11101 

Este é um código muito pobre e muito pequeno com M = 4 e n = 5 , mas ele

satisfaz os requisitos da definição. Nós podemos usar este código para representar
números binários com 2 bits, usando a seguinte correspondência arbitrária:
00 → 00000
01 → 01011
10 → 10110
11 → 11101
FAMAT em Revista - Número 06 - Maio de 2006 79

Suponhamos que temos um robô que se move sobre um tabuleiro quadriculado,

de modo que, ao darmos um dos comandos (para frente, para trás, para direita ou para
esquerda), o robô se desloca do centro de uma casa para o centro de outra casa adjacente
indicada pelo comando. Os quatro comandos acima podem ser codificados como
elementos de {0,1} x {0,1} , como se segue:

Para frente 00 Para direita 10

Para trás 01 Para esquerda 11

O código acima é chamado de código da fonte. Suponhamos, agora, que esses

pares ordenados devam ser transmitidos via rádio e que o sinal no caminho sofra
interferências. Imaginemos que a mensagem 00 possa, na chegada ser recebida como
01, o que faria com que o robô, em vez de ir para frente, fosse para trás. O que se faz,
então, é recodificar as palavras, de modo a introduzir redundâncias que permitam
detectar e corrigir erros.
Podemos, por exemplo, modificar o nosso código da fonte como já fizemos
anteriormente:

00 → 00000
01 → 01011
10 → 10110
11 → 11101

Nessa recodificação, as duas primeiras posições reproduzem o código da fonte,

enquanto que as três posições restantes são redundâncias introduzidas. O novo código
introduzido na recodificação é chamado de código do canal.
Suponhamos que se tenha introduzido um erro ao transmitirmos, por exemplo, a
palavra 01011, de modo que a mensagem recebida seja 11011. Comparando essa
mensagem com as palavras do código, notamos que não lhe pertence e, portanto,
detectamos erros. A palavra do código mais próxima da referida mensagem (a que tem
menor números de componentes diferentes) é 01011, que é precisamente a palavra
transmitida.

O procedimento acima está esquematizado abaixo:

80 FAMAT em Revista - Número 06 - Maio de 2006

fonte Codificador Codificador

da fonte de canal

Decodificador Decodificador
de canal da fonte Usuário

O nosso estudo consiste em detectar e corrigir erros na palavra recebida e,

depois de corrigidos os erros, relacioná-la à palavra transmitida e transformar a palavra
transmitida em código fonte para o usuário.
Quando recodificamos o código fonte, de modo a introduzir redundâncias que
permitam detectar e corrigir erros, esta recodificação não precisa ter obrigatoriamente o
código fonte inserido. Por exemplo, no código do robô poderíamos ter feito a seguinte
recodificação:

10101  00 → 10101
10010 
  01 → 10010
C= 
01110 10 → 01110
11111  11 → 11111

Os dois códigos criados para o exemplo do robô não são códigos bons, pois eles
não são capazes de corrigir muitos tipos de erros. Vamos exemplificar:
Note que no primeiro código a escolha da palavra código 01011 para estimar a
mensagem recebida 11011 é feita de maneira bem natural. De fato, em relação às
palavras do código observamos que:

11011 00000 → 4 diferenças

01011 → 1 diferença
10110 → 3 diferenças
11101 → 2 diferenças

Suponhamos que tivéssemos recebido a mensagem 01110 . Nesse caso, em

relação às palavras do código teríamos:

01110 00000 → 3 diferenças

01011 → 2 diferenças
10110 → 2 diferenças
11101 → 3 diferenças

Nesse caso, não é possível estimar qual foi a palavra código transmitida.
FAMAT em Revista - Número 06 - Maio de 2006 81

O ponto de partida para a construção de um código corretor de erros é definir o

alfabeto A com um número finito de q símbolos. No caso dos códigos binários A = {0 ,
1}.
Um código corretor de erros é um subconjunto próprio qualquer de
A = A × A × A × … × A , para algum número natural n. O número de elementos de um
n

conjunto A será denotado por |A|.

O código do robô é um subconjunto próprio de A5 , com A = {0 , 1}, onde
A5 = {(00000 ); (00001); (00010 ); (00100 );......; (11111)} e | A5 | = 25 = 32
Para que possamos identificar as palavras mais próximas de uma dada palavra
recebida com erro e estimar qual foi a palavra do código transmitida, vamos apresentar
um modo de medir a “distância”entre palavras em An.

Definição 1.1: Dados dois elementos u, v ∈ An , a distância de Hamming entre u e v é

u = (u 1 ,......, u n )
definida como d(u,v) = | { i : ui ≠ vi , 1≤ i ≤ n}| , onde 
v = ( v1, ......., v n )

Exemplo: Calculando a distância no código do robô:

d ( 00000, 01011) = 3
d ( 00000, 10110) = 3
d ( 00000, 11101) = 4
d ( 01011, 10110) = 4
d ( 01011, 11101) = 3
d ( 11101, 10110) = 3

Propriedades 1.1 : Dados u, v, w ∈ An , valem as seguintes propriedades:

(i) Positividade: d(u,v) ≥ 0 , valendo a igualdade se , e somente se, u = v .

(ii) Simetria: d(u,v) = d(v,u)
(iii) Desigualdade Triangular: d(u,v) ≤ d(u,w) + d(w, v)

Demonstração:

(i) Temos por definição que d(u,v) = | { i : ui ≠ vi , 1≤ i ≤ n}| ≥ 0. Caso d(u,v) = 0 ,

temos que ui = vi para i = 1, ..., n e daí u = v . Se u = v, temos que uj = vj,, para 1≤ j ≤ n
e conseqüentemente d(u,v) = 0

(ii) Pela definição de distância de Hamming temos que d(u,v) = | { i : ui ≠ vi , 1≤ i ≤ n}|

= | { i : vi ≠ ui , 1≤ i ≤ n}| = d(v,u)

(iii) Para demonstrar esta propriedade vamos considerar a i-ésima coordenada de u, v,

w.
n
Dados u, v, w ∈ A com u = ( u1 , ...... , un) ; v = (v1 , ....... , vn ) ; w = (w1 ,.......... ,
wn) podemos analisar as seguintes possibilidades para cada i, com 1≤ i ≤ n:

Caso I: ui = vi ui = wi ⇒ wi = vi

ui ≠ wi ⇒ wi ≠ vi
82 FAMAT em Revista - Número 06 - Maio de 2006

Para esta situação temos que se ui = wi então, wi = vi . Logo, a contribuição da

i-ésima coordenada para d(u,v) é zero, o que também ocorre pra d(u,w) e d(w,v) , ou
seja, as contribuições são iguais.
Por outro lado, se ui ≠ wi , teremos também que wi ≠ vi . Logo, a contribuição
da i-ésima coordenada para d(u,w) e d(w,v) será 1, ou seja, as contribuições são maiores
para d(u,w) + d(w,v).

Caso II: ui ≠ vi ui = wi ⇒ wi ≠ vi

ui ≠ wi wi ≠ vi

wi = vi

Para esta situação temos que se ui = wi então wi ≠ vi . Logo, a contribuição da

i-ésima coordenada para d(u,w) é zero e a contribuição da i-ésima coordenada para
d(u,v) e d(w,v) será 1. Assim, as contribuições para d(u,v) são iguais as contribuições
para d(u, w) + d(w, v) .
Agora para a situação onde ui ≠ wi temos que se wi ≠ vi , a contribuição da i-
ésima coordenada será 1 para todos, assim teremos que as contribuições para d(u,v)
serão menores que as contribuições para d(u,w) + d(w,v). E se wi = vi a contribuição da
i-ésima coordenada para d(w,v) é zero e a contribuição da i-ésima coordenada para
d(u,v) e d(u,w) será 1. Assim, as contribuições para d(u,v) são iguais as contribuições
para d(u, w) + d(w, v) .
Assim somando todas as contribuições com i = 1,2,…,n , teremos que
d ( u , v) ≤ d ( u , w ) + d ( w , v) .
As propriedades i) , ii) e iii) caracterizam o que se costuma, em matemática,
chamar de métrica. Por isso, a distância de Hamming entre elementos de An é também
chamada de métrica de Hamming.

Definição 1.2: Dados um elemento a ∈ An e um número real t >0 , definimos o disco e a

esfera de centro a e raio t como sendo, respectivamente, os conjuntos:

D (a,t) = {u ∈ An : d(u,a) ≤ t}
S (a,t) = {u ∈ An : d(u,a) = t}

Exemplos: i) Considere A = {0,1} e n = 4

{ (0,0,0,0) , (0,0,0,1) , (0,0,1,0) , (0,1,0,0) , (1,0,0,0) , (1,0,0,1)

4
Nesse caso A = (1,0,1,0) , (1,1,0,0) , (0,1,0,1) , (0,1,1,0) , (0,0,1,1) , (1,1,1,0)
(0,1,1,1) , (1,0,1,1) , (1,1,0,1) , (1,1,1,1) }

Assim, para a = (0,0,0,0) temos que :

D (a,1) = { (0,0,0,0) , (0,0,0,1) , (0,0,1,0) , (0,1,0,0) , (1,0,0,0)}

S (a,1) = { (0,0,0,1) , (0,0,1,0) , (0,1,0,0) , (1,0,0,0)}

Note que A4 = D(a,4)

FAMAT em Revista - Número 06 - Maio de 2006 83

Temos que F é o corpo de Galois e, para cada número natural n, teremos

um F-espaço vetorial Fn de dimensão n.

ii) Considere F 3 = {(0,0,0) , (1,0,0) , (0,1,0) , (0,0,1) , (1,0,1) , (1,1,0) , (0,1,1) , (1,1,1)}

Assim, para a = (0,0,0) temos que :

D ((0,0,0),2) = { (0,0,0) , (0,0,1) , (1,0,0) , (0,1,0) , (1,0,1) , (1,1,0) , (0,1,1) }

S ((0,0,0),2) = { (1,0,1) , (0,1,1) , (1,1,0)}

Definição 1.3: Seja C um código. A distância mínima de C é o número:

d = min { d(u,v) : u , v ∈ C e u ≠ v}

Por exemplo, se C é o primeiro código do robô temos que:

d ( 00000, 01011) = 3
d ( 00000, 10110) = 3
d ( 00000, 11101) = 4
d ( 01011, 10110) = 4 Distância mínima d = 3
d ( 01011, 11101) = 3
d ( 11101, 10110) = 3

Por exemplo, se C é o segundo código do robô temos que:

d ( 10101 , 10010) = 3
d ( 10010 , 01110) = 3
d ( 10101 , 01110) = 4
d ( 10010 , 11111) = 4 Distância mínima d = 2
d ( 10101 , 11111) = 2
d ( 01110 , 11111) = 2

M
Nesse caso, para calcular d é necessário calcular   distâncias, onde M é o
2
 
número de palavras do código, o que tem custo computacional elevado.

Proposição 1.2 – Seja C um código com distância mínima d. Se c e c’ são palavras

 d − 1
distintas de C, então D(c,t) ∩ D (c’, t) = ∅ , onde t = 
 2 
Obs: [ * ] : parte inteira do número *
84 FAMAT em Revista - Número 06 - Maio de 2006

d(c,c’) ≥ d

d(c, c' )
2
Obs: os raios das circunferências têm medida t.

Demonstração:

De fato, se x pertencesse a D(c,t) ∩ D (c’, t), teríamos d(x,c) ≤ t e d(x,c’) ≤ t , e

portanto pela simetria, pela desigualdade triangular e pela definição de t teríamos:

d(c,c’) ≤ d(c,x) + d(x, c’) ≤ t + t = 2t ≤ d – 1 (Absurdo)

Como d é a distância mínima de C, temos necessariamente que d(c,c’) ≥ d.

∵ x ∉ D(c,t) ∩ D (c’, t)
∵ D(c,t) ∩ D (c’, t) = ∅

Teorema 1: Seja C um código com distância mínima d . Então C pode

 d − 1
corrigir até t =
 2  erros. Se d é par, o código pode simultaneamente corrigir
d −2 d
erros e detectar até erros.
2 2
Demonstração:

Se ao transmitirmos uma palavra c do código cometemos s erros com s ≤ t,

recebendo a palavra r, então d(r,c) = s ≤ t
FAMAT em Revista - Número 06 - Maio de 2006 85

d(c,c’) ≥ d

Como D(c,t) ∩ D(c’,t) = ∅ , temos que d(r,c’) > t, para toda palavra c’ ∈ C ,
com c’ ≠ c e, portanto, a decodificação pela vizinhança mais próxima vai corrigir este
erro, pois c está univocamente determinado a partir de r.
 d − 1 d −2
Agora se d for par, então
 2  = . Conseqüentemente, C pode
2
d −2 d
corrigir erros. Mas, se ocorreu, isso significa que a palavra recebida r tem
2 2
d
d(c,r) = . Se existe alguma palavra c’ ∈ C tal que d(c,c’) = d , teremos que r pode
2
d
estar no “ponto médio” entre c e c’, Nesse caso, d(c’,r) = e o decodificador pode
2
d
detectar que erros ocorreram, mas não pode corrigi-los pois existem duas
2
possibilidades distintas c e c’ para efetuar a decodificação pela vizinhança mais
próxima.

d
d
t 2
2
t
r
86 FAMAT em Revista - Número 06 - Maio de 2006

d
Por outro lado, se mais de erros ocorrem, a palavra recebida r pode estar mais
2
próxima de outra palavra do código que não a correta.

d
d(c,r) > t t
2 r
e d(c’,r) < t

d d
2 2
Nesse caso, a decodificação de r determinará c’ incorretamente. Isto é chamado
erro de decodificação. Em um código eficiente, isto raramente ocorre.

 d − 1
Por exemplo em um código com d = 4, é possível corrigir até t =
 2  = 1 erro e
d
detectar até = 2 erros. Note que pelo teorema anterior, um código terá maior
2
capacidade de correção de erros quanto maior for a sua distância mínima. Portanto, é
fundamental, para a Teoria de Códigos, poder calcular d, ou pelo menos determinar uma
cota inferior para ele.

 d − 1
Definição 1.4: Seja C ⊂ An um código com distância mínima d e seja t =
 2  . O
código C será dito perfeito se ∪ D ( c, t ) = A
c∈C
n
FAMAT em Revista - Número 06 - Maio de 2006 87

Exemplos:

1 – O código do robô não é perfeito, pois ele é um código C ⊂ A5 ,

onde C = { ( 0,0,0,0,0) ; (0,1,0,1,1) ; (1,0,1,1,0) ; (1,1,1,0,1) } e além disso, temos que
∪ D(c,1) ≠ A5
c∈C

2 – Todo código de Hamming é perfeito (falaremos deste tipo de código no capítulo II)
88 FAMAT em Revista - Número 06 - Maio de 2006

CAPÍTULO II

CÓDIGOS LINEARES

A classe de códigos mais utilizada na prática é a chamada classe dos códigos

lineares. Denotaremos por F um corpo finito com q elementos tomado como alfabeto.
No caso dos códigos binários q = 2 e F é o corpo de Galois. Temos, portanto, para cada
número natural n, um F-espaço vetorial Fn de dimensão n.

Definição 2.1: Um código C ⊂ Fn será chamado de código linear se for um subespaço

vetorial de Fn.

Desse modo, C é por definição um espaço vetorial de dimensão finita.

Denotaremos por k a dimensão do código C. Conseqüentemente, todo elemento de C se
escreve de maneira única na forma: (*) λ1v1 + λ2v2 + .... + λkvk ; λi ∈ F , i = 1,2,..., k
onde v1,...,vk é uma base de C.
Como λi ∈ F, i = 1,2,..., k , existem q possibilidades para cada um dos λi em (*) .
Logo, existem qk elementos em C, ou seja, M = |C| = qk e conseqüentemente
dim C = k = k log q q = log q q k = log q M .

Definição 2.2: Dado u ∈ Fn, defini-se o peso de u como sendo o número inteiro:

w(u) := | { i: ui ≠ 0} |

Ou seja, w(u) = d(u, 0), em que 0 é o vetor nulo de Fn.

Definição 2.3: O peso de um código linear C, é o inteiro w(C) = min{w(u) : u ∈ C –

{0}}.

Proposição 2.1: Seja C ⊂ Fn um código linear com distância mínima d . Temos que:

(i) ∀ u , v ∈ Fn ; d(u,v) = w(u-v)

(ii) d = w(C)

Demonstração:

(i) d(u,v) = | {i: ui ≠ vi , 1 ≤ i ≤n}| = | {i: ui – vi ≠ 0 , 1 ≤ i ≤n}| = w(u-v)

(ii) Para todo par de elementos u,v ∈ C , com u ≠ v , temos que z = u – v ∈ C . Daí,
d(u,v) = w(z) . Portanto, o conjunto {w(z): z ∈ C –{0} } é igual ao conjunto
{d(u,v) : u,v ∈ C e u ≠ v} e daí d = min {d(u,v) : u,v ∈ C e u ≠ v}=
min {w(z): z ∈ C –{0} }= w(C).
FAMAT em Revista - Número 06 - Maio de 2006 89

Em virtude disto, a distância mínima de um código linear C será também

chamada de peso do código C.

2.1 – Como construir códigos lineares

Em álgebra linear, se conhecem essencialmente duas maneiras de se descrever

subespaços vetoriais C de um espaço vetorial Fn , uma como imagem, e outra como
núcleo de transformação linear.
Vamos obter a representação de C como imagem de uma transformação linear.
Escolha uma base v1, v2, ...., vk de C e considere a aplicação linear:

T: Fk → Fn
a → u

onde a = (a1, a2, ...., ak) e u = a1v1 + a2v2 + .... + akvk . Temos que T é uma
transformação linear injetora, pois o Ker T = { 0} , tal que Im(T) = C.
Portanto, dar um código C ⊂ Fn de dimensão k é equivalente a dar uma
transformação linear injetora T: Fk → Fn e definir C = Im(T)

Exemplo: Considere a transformação linear:

T: F22 → F24
(a1,a2) → (a1, a2, a2, a1)

Temos que T(a1,a2) = (0,0,0,0) , se (a1, a2, a2, a1) = 0 , ou seja, a1 = a2 = 0 . Logo,
Ker T = { (0,0) } . Portanto, T é injetora e daí Im T = C ( a imagem de T é um código
C).
Como a1 , a2 ∈ F2 , temos que | C | = 22 = 4 e:
C = { (0,0,0,0) ; (1,0,0,1) ; (0,1,1,0) ; (1,1,1,1) }
 d − 1
Além disso, w(C) = 2 e C corrige t =
 2  = 0 erros, ou seja, é um código
muito ruim.

2.2 – Matriz Geradora de um Código.

Definição 2.4: Dado um código linear C ⊂ Fn , chamaremos de parâmetros do código

linear C os inteiros (n, k, d), onde k é a dimensão de C sobre F , d representa a distância
mínima de C e n é denominado o comprimento do código C.

Seja β = {v1, v2, ..., vk} uma base ordenada de C e considere a matriz G , cujas
linhas são os vetores vi = (vi1, vi2, ...., vin) ; i = 1,2,...,k , isto é ,
90 FAMAT em Revista - Número 06 - Maio de 2006

 v1   v11 v12 ..... v1n 

   
v v
 2   21 22v ..... v 2n 
 
G= . = .  ... ... . 
   
  
. . .... ... . 
v  v 
 k   k1 vk 2 .... vkn 

A matriz G é chamada de matriz geradora de C associada à base β.

Exemplo: No exemplo anterior, considere β = { (1,0,0,1) ; (0,1,1,0) }e daí teremos:

1 0 0 1
G =  
 0 1 1 0
Utilizando esta matriz geradora G para codificar as palavras código da fonte, do
exemplo do robô, teríamos as seguintes palavras do código.

1 0 0 1
(0,0) . G = (0 0 ).  = (0 0 0 0 )
0 1 1 0

1 0 0 1
(1,0) . G = (1 0 ).  = (1 0 0 1)
0 1 1 0 

1 0 0 1
(0,1) . G = (0 1).  = (0 1 1 0 )
0 1 1 0 

1 0 0 1
(1,1) . G = (1 1).  = (1 1 1 1)
0 1 1 0 

Fonte Palavra Palavra

código código
Da fonte Do canal
Para frente 00 0000
Par trás 01 0110
Para direita 10 1001
Para esquerda 11 1111

Codificador Codificador
da fonte do canal
FAMAT em Revista - Número 06 - Maio de 2006 91

De maneira geral, consideramos a transformação linear definida por:

T : Fk → Fn
a → aG

Se a = (a1, a2, ..., ak), temos que T(a) = aG = (a1v1 + a2v2 + .... + akvk), ou seja,
T(Fk) = C. Podemos, então, considerar Fk como sendo um código da fonte, C o código
do canal e a transformação T, uma codificação.
Além disso, devemos ressaltar que a matriz geradora G não é única, pois ela
~
depende da base β. Portanto, mudando para uma base β , teremos uma outra matriz
~ ~
geradora G para o mesmo código C. Da álgebra linear, sabemos que podemos obter G
de G através de operações elementares com as linhas de G e vice versa.
Podemos construir códigos a partir de matrizes geradoras G. Para isto, basta
tomar uma matriz cujas linhas sejam linearmente independentes e definir um código
como sendo a imagem da transformação linear T : Fk → Fn
a → aG

2.3 – Equivalência de Códigos

Definição 2.5: Sejam F um alfabeto e n um número natural. Diremos que uma função
f : Fn → Fn é uma isometria de Fn se ela preserva distâncias de Hamming, ou seja:

d(f(u),f(v)) = d(u,v) ; u, v ∈ Fn

Definição 2.6: Dados dois códigos C e C’ em Fn, diremos que C’ é equivalente a C se

existir uma isometria f de Fn tal que f(C) = C’.

Decorre dessa definição que dois códigos equivalentes têm os mesmos

parâmetros n, k, d, pois f é injetora ⇒ leva base em base (k)
f é isometria ⇒ preserva distância (d)
f : Fn → Fn (n)

Temos que a equivalência de códigos é uma relação de equivalência (Reflexiva,

Simétrica e Transitiva).
Uma maneira mais simples de se obter a partir de um código linear C um código
C’ equivalente é efetuando-se seqüências de operações sobre a matriz geradora G do
código linear C, do tipo:

• Permutação de duas colunas

• Multiplicação de uma coluna por um escalar não nulo.

Nesse caso, obteremos uma matriz geradora G’ de um código linear C’ equivalente a

C, notando que efetuar operações deste tipo em G, implica efetuá-las em todas as
palavras de C, o que caracteriza a isometria f.
Fazendo as operações elementares sobre as linhas ou sobre as colunas de G,
podemos colocar G na forma padrão. Chamaremos de G* a matriz G na forma padrão.
92 FAMAT em Revista - Número 06 - Maio de 2006

[
G * = Id k A ]
Portanto, dado um código C, existe um código equivalente C’ com matriz geradora
G* na forma padrão.

Exemplo: Dado o código C definido sobre F2 pela matriz G abaixo, encontre um código
C’ equivalente a C, com matriz geradora na forma padrão. T : F4 → F7

1 1 1 0 0 0 0
 
1 0 0 1 1 0 0
G=
1 0 0 0 0 1 1
0 0 
 1 0 1 0 1

De G, temos que k = 4 , n = 7 , e |C| = 24 = 16

L  1 1 1 0 0 0 0 c ↔c
1
  3 1
1 0 1 0 1 0 0
L
2 1 0 0 1 1 0 0  c5 ↔ c2   c7 ↔ c3
L  1 0 0 0 0 1 1 0 1 1 1 0 0 0
3
L 
 0 1 0 1 0 1 0 
≈ 0 0 1 0 0 1 1 ≈
4 0 0 
 0 0 1 1 1
c1 c 2 c3 c4 c5 c6 c7

1 0 0 0 1 0 1 1 0 0 0 1 0 1
   
0 1 0 1 0 0 1  L4 + L2 0 1 0 0 1 1 1
= [Id 4 A ] onde,
0 0 1 0 0 1 1
≈ 0 0 1 0 0 1 1
0 0  0 0 
 0 0 1 1 1  0 0 1 1 1

1 0 0 0 1 0 1
   
0 1 0 0 1 1 1
Id 4 =  e A=

0 0 1 0
 0 1 1
0  
 0 0 1  kxk = 4x4 1 0  kx ( n − k ) = 4 x3
1

2.4 – Códigos Duais

Sejam u = (u1, u2,...,un) e v= (v1, v2 ,..., vn) elementos de Fn. Define-se o produto
interno de u e v como sendo u, v = u1v1+u2v2+....+unvn . Essa operação possui as
seguintes propriedades usuais de um produto interno, ou seja, é simétrica :
u, v = v, u e bilinear u + λw, v = u, v + λ w, v ∀ λ ∈ F
FAMAT em Revista - Número 06 - Maio de 2006 93

Definição 2.7: Seja C ⊂ Fn um código linear. Define-se C⊥ =

{
v ∈ F n : v, u = 0, ∀ u ∈ C . }
Proposição 2.2: Se C∈ Fn é um código linear, com matriz geradora G, então:

(i) C⊥ é um subespaço vetorial de Fn;

(ii) v ∈ C⊥ ⇔ G.vt = 0

Demonstração:

(i) Dados u , v ∈ C⊥ e λ ∈ F, temos, ∀ w ∈ C, que:

u + λv, w = u, w + λ v, w = 0 + λ0 = 0 . Portanto u + λv ∈ C⊥ , provando que C⊥
é um subespaço vetorial de Fn .

(ii) v∈ C⊥ ⇔ v é ortogonal a todos os elementos de C ⇔ v, u = 0 ∀ u ∈ C ⇔ v é

ortogonal a todos os elementos de uma base de C ⇔ Para uma base β = {u1,u2,....,uk}de
C, =0 ; i =
v, u 1,2,..,k , o que é equivalente a dizer que:
i
(u1 , v , u 2 , v ,...., u k , v ) = 0 ⇔ Gv = 0 , pois todas as linhas de G são elementos
t

de uma base de C.

O subespaço vetorial C⊥ de Fn, ortogonal a C é também um código linear que

será chamado de código dual de C.

Proposição 2.3: Seja C ⊂ Fn um código de dimensão k com matriz geradora

(
na forma padrão G = Id k A . Então: )
(i) dim C⊥ = n – k
( )
(ii) H = − A t Id n−k é uma matriz geradora de C⊥ .

Demonstração:

(i) Temos que v ∈ C⊥, se e somente se, Gvt = 0. Se v = (v1,v2,...,vn) temos o

seguinte sistema:
1 0 0 0 0 | a1,k +1 a1,n   v1  0
     
0 1 0 0 0 | a 2,k +1 a 2,n     
0 0   

|
 . = 
   
 1 0 |     
  v   
0 0 0 1 | a k,k +1 a k ,n   n  nx1  0  kx1
  kxn

Daí:
94 FAMAT em Revista - Número 06 - Maio de 2006

v1 + a1,k +1.v k +1 + + a1,n .v n = 0


 v2 a 2,k +1.v k +1 + + a 2,n .v n = 0

 ⇒


 vk a k,k +1.v k +1 + + a k,n .v n = 0

(
v1 = − a1,k +1.v k +1 + ...... + a1,n .v n )  v1 
 
 v k +1 
 

⇒

(
v 2 = − a 2,k +1.v k +1 + ...... + a 2,n .v n ) ⇒
 v2   v k +2 
  = −A . 
    

v = − a
 k (
k,k +1.v k +1 + ...... + a k, n .v n )  
 v 
 k

 v 
 n 


Logo temos que:

v = (v1,v2,..,vn) =
v = (− (a 1,k +1 .v k +1 + ... + a 1,n .v n ),−(a 2,k +1 .v k +1 + ... + a 2,n .v n ),..., − (a k ,k +1 .v k +1 + ... + a k ,n .v n ), v k +1 , v k + 2 ,.., v n
v = v k +1 (− a 1,k +1 ,−a 2,k +1 ,....,−a k ,k +1 ,1,0,...,0 ) + ...... + v n (− a 1,n ,−a 2,n ,....,−a k ,n ,0,0,0,...,1)
em que vk+1 , vk+2 , ... , vn ∈ F . Como F possui q elementos, existem qn-(k+1)+1 = qn – k
possibilidades para v, ou seja, C⊥ possui qn-k elementos, o que significa que sua
dimensão é n – k .

(ii) Temos que as linhas de H são linearmente independentes, devido ao bloco Idn-k .
Portanto geram um subespaço vetorial de dimensão n – k. Temos que a i-ésima linha de
k elementos n − k elementos

H, denotada por Hi ; 1 ≤ i ≤ n – k, será H i = (− a 1i ,−a 2i ,...,−a ki , 0,0,....,1,0,...0) e a j-

ésima
Posição i

 k elementos n − k elementos 
 
linha de G, denotada por Gj ; 1 ≤ i ≤ k , será Gj =  0,0,...,1,0,..0,0, a j1 , a j2 ,..., a j,n −k 
 
 
Posição j

Daí, H i , G j = -aji + aij = 0 , ou seja, todas as linhas de H são ortogonais às

linhas de G. Portanto, o espaço gerado pelas linhas de H está contido em C⊥, e como
esses dois subespaços têm a mesma dimensão, eles coincidem, provando assim que H é
uma matriz geradora de C⊥ .

Proposição 2.4: Suponha que C seja um código de dimensão k em Fn com matriz

geradora G. Uma matriz H de ordem (n – k) x n, com coeficientes em F e com linhas
linearmente independentes, é uma matriz geradora de C⊥ se, e somente se, G . Ht = 0.
FAMAT em Revista - Número 06 - Maio de 2006 95

Demonstração: As linhas de H geram um espaço vetorial de Fn de dimensão n – k,

portanto, igual à dimensão de C⊥. Por outro lado, temos que Dji = G j , H i , 1≤ j ≤ k e
t
1≤ i ≤ n – k que é equivalente a fazer o produto G kxn .H nx(n
t
− k) , ou seja, D = G.H .

Portanto, G.Ht = 0 é equivalente a dizer que todos os vetores do subespaço

gerado pelas linhas de H estão em C⊥. Por outro lado, esse subespaço tem a mesma
dimensão de C⊥, logo:

G.Ht = 0 ⇔ C⊥ é gerado pelas linhas de H

Corolário 2.1: (C⊥)⊥ = C

Demonstração: G.Ht = 0 ⇔ H.Gt = 0. Portanto (C⊥)⊥ = C

H gera o dual C⊥
G gera o dual (C⊥)⊥

Conseqüentemente:

Proposição 2.5: Seja C um código linear e suponhamos que H seja uma matriz geradora
de C⊥. Temos então que: v ∈ C ⇔ Hvt = 0

Demonstração: v ∈ C ⇔ v ∈ (C⊥)⊥ ( pelo corolário 2.1) ⇔ H.vt=0 (pela proposição

2.2)

Esta proposição nos permite caracterizar os elementos de um código C por uma

condição de anulamento. A matriz H geradora de C⊥ é chamada matriz teste de
paridade de C.
Portanto, para verificar se um determinado vetor v ∈ Fn pertence ou não a um
código C, com matriz teste de paridade H, basta verificar se H.vt é o vetor nulo ou não.

Exemplo : Seja dado o código C sobre F2 com matriz geradora

1 0 0 0 | 1 0 1
 
0 1 0 0 | 1 1 1
G = . Determine se o vetor v = (1010101) ∈ F27 pertence a
0 0 1 0 | 0 1 1
 
0 0 0 1 | 1 1 0 

C.
96 FAMAT em Revista - Número 06 - Maio de 2006

1 0 1
  1 1 0 1
1 1 1  
Nesse caso, temos A =  e –At =  0 1 1 1  e daí
0 1 1 1 1 1 0
   
1 1 0 

1 0 0 | 1 1 0 1
 
H =  0 1 0 | 0 1 1 1  . Além disso,
 0 0 1 | 1 1 1 0
 
1
 
0
1 0 0 1 1 0 1 1 1 + 1 + 1  1 
t        
H.v =  0 1 0 0 1 1 1  . 0  =  1 + 1  =  0  ∴v∉C
 0 0 1 1 1 1 0 1  1 + 1  0
  3x7      
0
 
 1  7x1

Definição 2.8: Dados um código C, com matriz teste de paridade H, e um vetor v ∈ Fn ,

chamamos o vetor H.vt de síndrome de v

Além de determinar de maneira simples se um vetor v ∈ Fn pertence ou não a

um código C, a matriz teste de paridade de C contém, de maneira bastante simples,
informações sobre o valor do peso w do código C.

Vejamos:

Proposição 2.6: Seja H a matriz teste de paridade de um código C. Temos que o peso
de C é maior do que ou igual a s se, e somente se, quaisquer s –1 colunas de H são
linearmente independentes.

Demonstração:
(⇐) (*) Suponhamos que cada conjunto de s – 1 colunas de H é linearmente
independente.

Seja c ∈ C – {0} , c = (c1, c2, ...,cn) e sejam h1, h2, ..., hn as colunas de H.
Como H.ct = 0, temos c1h1 + c2h2 + .... + cnhn = 0 . Além disso, sabemos que w(c) é o
número de ci ≠ 0 ; i = 1,...,n. Logo se w(c) ≤ s – 1, teríamos uma combinação de s – 1 ou
menos colunas de H igual ao vetor nulo, com coeficientes ci não todos nulos. Isto é
um absurdo pois (*). Logo, w(c) ≥ s ∀ c ∈ C e, portanto w(C) ≥ s.

(⇒) (**) Suponhamos que w(C) ≥ s.

FAMAT em Revista - Número 06 - Maio de 2006 97

Considere por absurdo que H tenha pelo menos um conjunto com s – 1 colunas
linearmente dependentes, digamos hi1, hi2, ..., hi,s-1. Logo, existiria ci1,ci2,...., ci,s-1 ∈ F,
nem todos nulos , tais que ci1hi1 + ci2hi2 +....+ ci,s-1hi,s-1 = 0 o que é equivalente a H.ct =
0, com c = (0,..., ci1, 0,...., ci,s-1, 0,....,0) ∈ Fn . Nesse caso, c∈ C e w(c) = s – 1, o que é
um absurdo por (**)

Teorema 2: Seja H a matriz teste de paridade de um código C. Temos que o peso de C

é igual a s, se somente se, quaisquer s – 1 colunas de H são linearmente independentes e
existem s colunas de H linearmente dependentes.

Demonstração:

(⇒) (*) Suponhamos w(C) = s.

Pela proposição anterior todo conjunto de s – 1 colunas de H é linearmente

independente. Se não existir pelo menos um conjunto com s colunas de H linearmente
dependentes, teríamos pela proposição anterior que w(C) ≥ s + 1 . Absurdo por (*)
Portanto, existe pelo menos um conjunto com s colunas de H que é linearmente
dependentes.

(⇐) (**) Todo conjunto com s –1 colunas de H é LI e existe um conjunto com s colunas
de H que é LD.
Da proposição anterior temos que w(C) ≥ s . Mas w(C) não pode ser estritamente
maior do que s, pois pela proposição anterior , todo conjunto com s colunas de H seria
linearmente independentes. Absurdo por (**) . Portanto , w(C) = s

Corolário 2.2: Cota de Singleton: Os parâmetros (n,k,d) de um código linear satisfazem

à desigualdade d ≤ n – k + 1

Demonstração:

Se H é uma matriz teste de paridade de um código linear C, com parâmetros

(n,k,d), ela tem posto n – k, pois H é uma matriz de ordem (n – k)xn, ou seja, n – k
linhas linearmente independentes. Desse modo, cada coluna de H tem n – k entradas, ou
seja, comprimento n – k, ou ainda então em Fn-k. Pelo teorema anterior, quaisquer d – 1
colunas de H são linearmente independentes.
Como um conjunto de vetores de Fn-k que é LI tem no máximo n – k vetores,
então d – 1 ≤ n – k . Daí d ≤ n – k + 1.

2.5 Decodificação

Chama-se decodificação ao procedimento de detecção e correção de erros num

determinado código.
Inicialmente, define-se o vetor erro e como sendo a diferença entre o vetor
recebido r e o vetor transmitido c.
98 FAMAT em Revista - Número 06 - Maio de 2006

e=r–c

Se H é a matriz teste de paridade do código, temos que:

Het = H(r – c)t = Hrt – Hct = Hrt , pois Hct = 0

Portanto, a palavra recebida r tem a mesma síndrome do vetor erro e.

Proposição 2.7: Seja C um código linear em Fn que corrige no máximo t erros. Se r ∈

Fn e c ∈ C são tais que d(c,r) ≤ t , então existe um único vetor e com w(e) ≤ t , cuja
síndrome é igual a síndrome de r e tal que c = r – e .

Demonstração

Se tomarmos e = r – c temos que w(e) = w(r –c) = d(r,c) ≤ t. Logo existe um

vetor e tal que w(e) ≤ t e c = r – e e Het = Hrt . Vamos mostrar que e é único.
Suponhamos que e = (α1 ,..., αn) e e’=(α’1 ,..., α’n)sejam tais que w(e) ≤ t e w(e’) ≤ t e
tenham a mesma síndrome que r. Então: Het = H(e’)t ⇒
n n n
∑ α i h i = ∑ α i' h i ⇒ ∑ (α i − α i' )h i = 0
i =1 i =1 i =1
Como w(e) ≤ t e w(e’) ≤ t , existem no máximo t entradas αi e α’j não nulos e,
conseqüentemente, no máximo 2t coeficientes (αi – α’i ), com i = 1,...,n, na combinação
n
linear ∑ (α i − α i' )h i = 0 , o que nos dá uma relação de dependência linear entre m
i =1
colunas de H com m ≤ 2t ≤ d – 1 . Como quaisquer d – 1 colunas de H são linearmente
independentes, temos que αi – α’i = 0 ⇒ αi = α’i , ∀ i = 1,...,n . Portanto, e = e’.

O problema que devemos resolver agora é determinar esse único vetor e a partir
t
de Hr .
Seja v ∈ Fn . Defina: v + C = { v + c : c∈ C}

Cada conjunto da forma v + C é chamado de classe lateral de v segundo C. Note

que v + C = C ⇔ v ∈ C.

Propriedades 2.8:

1 – Os vetores u, v ∈ Fn tem a mesma síndrome se, e somente se, u ∈ v + C.

Demonstração:

Hut = Hvt ⇔ H(u – v)t = 0 ⇔ u – v ∈ C ⇔ u ∈ v + C

2 – v + C = v’ + C ⇔ v – v’ ∈ C
3 – (v + C) ∩ (v’ + C) ≠ 0 ⇒ v + C = v’ + C
4 – ∪ ( v + C) = F n
v∈Fn
5 - |(v + C)| = |C| = qk
FAMAT em Revista - Número 06 - Maio de 2006 99

As demonstrações de 2 a 5 são imediatas. Além disso, concluímos de 3 e 5 que o

qn
número de classes laterais segundo C é k = q n −k .
q

1 0 1 1
Exemplo: Seja C o código gerado sobre F2 pela matriz G =   . Logo,
0 1 0 1
 00 10 01 11 

C = 0000, 1011, 0101, 1110 e as classes laterais segundo C são: qn-k = 24 – 2
= 4
 
classes. Como F24 tem 16 elementos, cada classe tem 4 elementos. As classes são as
seguintes:

0000 + C = { 0000, 1011, 0101, 1110 }

1000 + C = { 1000, 0011, 1101, 0110 }
0100 + C = { 0100, 1111, 0001, 1010 }
0010 + C = { 0010, 1001, 0111, 1100 }

Definição 2.9: Um vetor de peso mínimo numa classe lateral è chamado de elemento
líder dessa classe.

Proposição 2.9: Seja C um código linear em Fn com distância mínima d. Se u ∈ Fn é tal

 d − 1
que w(u) ≤  = t então u é o único elemento líder de sua classe.
 2 

Demonstração:

 d − 1  d − 1
Suponhamos u,v ∈ Fn com w (u ) ≤   e w ( v) ≤  . Se u e v são
 2   2 
 u ∈ y + C ⇒ u = y + c1

elementos da mesma classe, então u – v ∈ C , pois v ∈ y + C ⇒ v = y + c 2 . Nesse
u − v = c − c ∈ C
 1 2

 d − 1  d − 1
caso, w (u − v) ≤ w (u ) − w ( v) ≤  + ≤ d − 1 . Como w(a) ≥ d , ∀ a ∈ C ≠ 0,
 2   2 
temos que, u – v = 0 ⇒ u = v.

Portanto, para encontrarmos os líderes de classes, tomamos os elementos u ∈ Fn

 d − 1
tais que w (u ) ≤  = t . Cada um desses elementos é líder de uma e somente uma
 2 
classe.
 d − 1
Os líderes de classe v tais que w ( v) ≥  = t não serão considerados na
 2 
correção de erros.
100 FAMAT em Revista - Número 06 - Maio de 2006

Agora apresentaremos um algoritmo de correção de mensagens que tenham

 d − 1
sofrido um número de erros menor ou igual a t =  .
 2 

* Determine todos os elementos u ∈ Fn , tais que w(u) ≤ t. Em seguida calcule as

síndromes desses elementos e coloque esses dados numa tabela.

Seja r a palavra recebida:

(1) Calcule a síndrome st = Hrt

(2) Se s está na tabela construída em * , seja l o elemento líder da classe tal que Hlt
= st. Troque r por r – l
(3) Se s não está na tabela, então na mensagem recebida foram cometidos mais do
que t erros.

Justificativa:

Dado r, sejam c e e, respectivamente, a mensagem transmitida e o vetor erro.

Como Het = Hrt, temos que a classe lateral onde e se encontra está determinada pela
síndrome de r. Se w(e) ≤ t , temos que e é o único elemento líder l de sua classe e,
portanto, é conhecido e se encontra na tabela. Conseqüentemente, como c = r – e, temos
que c = r – l.
Se w(e) > t , e não é elemento líder de sua classe e portanto não está na tabela e é
desconhecido.

Exemplo: Considere o código linear definido sobre F2 com matriz teste de paridade
1 0 0 1 0 1
 
H =  0 1 0 1 1 0  . Note que 3 = n – k , como n = 6, então k = 3. Além disso,
0 0 1 0 1 1
 
2 a 2, as colunas de H são L.I. e existem três colunas 1, 2 e 4 L.D. Logo, d = 3 pois s – 1
= 2 e portanto, t = 1. Os vetores de F26 com w(u) ≤ 1 e suas respectivas síndromes estão
relacionados na tabela abaixo:

Líder Síndrome
000000 000
000001 101
000010 011
000100 110
001000 001
010000 010
100000 100

Suponhamos que a palavra recebida seja:

a) r = (100011) . Logo, Hrt = (010)t e, portanto e = (010000). Conseqüentemente,

c = r − e = (100011) − (010000 ) = (110011)
FAMAT em Revista - Número 06 - Maio de 2006 101

b) r = (111111) . Logo, Hrt = (111)t que não se encontra na tabela. Sendo assim, foi
cometido mais do que 1 erro na mensagem r.

2.6 – Códigos de Hamming

Códigos de Hamming são exemplos de códigos lineares perfeitos. Um código de

Hamming de ordem m sobre F2 é um código com matriz teste de paridade Hm de ordem
mxn , cujas colunas são os elementos de F2m \ {0} numa ordem qualquer. A definição de
Hm determina o código C a menos de equivalência. Temos, portanto, que o
comprimento de um código de Hamming de ordem m é n = 2m – 1 e,
portanto, a sua dimensão é k = n – m = 2m – m – 1 .
Verificamos facilmente que d = 3, pois, em Hm, é fácil achar três colunas
linearmente dependentes.
1 0 1 1 1 0 0
 
Como no exemplo numérico, considere a matriz H =  1 1 0 1 0 1 0  .
0 1 1 1 0 0 1
 
Essa é a matriz de um código de Hamming correspondente a m = 3.

Proposição: Todo código de Hamming é perfeito.

Demonstração:

 d − 1
No nosso caso t =   = 1 . Dado c em F2n , temos que D(c,1) = 1 + n . Portanto,
 2 

∪ D(c,1) = [1 + n ].2 k
[ ]
= 1 + 2 m − 1 .2 n − m = 2 n e conseqüentemente ∪ D(c,1) = F
n
2 .
c∈C c∈C
102 FAMAT em Revista - Número 06 - Maio de 2006

CAPÍTULO III

EXEMPLO DE UM CÓDIGO LINEAR

Considere o código binário C com matriz geradora

1 1 0 0 1 0 0 0 0
 
1 0 0 1 0 0 0 1 0
G = 1 1 1 0 0 0 0 0 1 .
 
0 1 0 1 0 1 0 0 0
0 0 1 1 0 0 1 0 0
 

a) Determine a dimensão, o comprimento e o número de elementos de C.

Observando a matriz geradora G do código binário C temos que G é uma matriz

de ordem k x n onde k é a dimensão de C e n é o comprimento do código C.
Assim temos que a dimensão de C é k = 5 e o comprimento de C é n = 9.
Para calcularmos o número de elementos de C , basta fazermos 2k = 25 = 32
elementos.

b) Construa uma matriz teste de paridade H de C e determine a distância mínima

d de C.

Obteremos a matriz teste de paridade H a partir da matriz geradora G.

1 1 0 0 1 0 0 0 0 1 1 0 0 1 0 0 0 0  L1 + L 2
   
1 0 0 1 0 0 0 1 0  L 2 + L1  0 1 0 1 1 0 0 1 0
G kxn = 1 1 1 0 0 0 0 0 1  L 3 + L1  0 0 1 0 1 0 0 0 1 ≈
   
0 1 0 1 0 1 0 0 0 ≈ 0 1 0 1 0 1 0 0 0 L4 + L2
0 0 1 1 0 0 1 0 0  0 0 1 1 0 0 1 0 0 
 

1 0 0 1 0 0 0 1 0 1 0 0 1 0 0 0 1 0
   
0 1 0 1 1 0 0 1 0 0 1 0 1 1 0 0 1 0
≈ 0 0 1 0 1 0 0 0 1  ≈ 0 0 1 0 1 0 0 0 1 ≈
   
0 0 0 0 1 1 0 1 0 0 0 0 0 1 1 0 1 0 L 4 + L5
0 0 1 1 0 0 1 0 0  L 5 + L 3  0
 0 0 1 1 0 1 0 1 

FAMAT em Revista - Número 06 - Maio de 2006 103

1 0 0 1 0 0 0 1 0 1 0 0 1 0 0 0 1 0  L1 + L 4
   
0 1 0 1 1 0 0 1 0 0 1 0 1 1 0 0 1 0 L2 + L4
≈ 0 0 1 0 1 0 0 0 1  ≈ 0 0 1 0 1 0 0 0 1 ≈
   
0 0 0 1 0 1 1 1 1 0 0 0 1 0 1 1 1 1
0 0 0 1 1 0 1 0 1  L 5 + L 4  0
 0 0 0 1 1 0 1 0 


1 0 0 0 0 1 1 0 1 1 0 0 0 0 1 1 0 1
   
0 1 0 0 1 1 1 0 1  L 2 + L5  0 1 0 0 0 0 1 1 1
≈ 0 0 1 0 1 0 0 0 1  L3 + L5  0 0 1 0 0 1 0 1 1  = G (Id 5 | A 5 x 4 )
   
0 0 0 1 0 1 1 1 1 ≈ 0 0 0 1 0 1 1 1 1
0 0 0 0 1 1 0 1 0  0 0 0 0 1 1 0 1 0 
 

1 0 1 1 1 | 1 0 0 0 1 0 1 1 1 1 0 0 0
   
( ) (
H = − A t | Id n −k = − A t | Id 4 ) 1
=
0
1
1
0
1
1
1
0
1
|
|
0
0
1
0
0
1
0 1
=
0  0
1
1
0
1
1
1
0
1
0
0
1
0
0
1
0
0
   
1 1 1 1 0 | 0 0 0 1   1 1 1 1 0 0 0 0 1 


Analisando as colunas 3 a 3 achamos colunas linearmente dependentes pois a

quinta coluna é igual a sexta coluna mais a oitava coluna.
Analisamos as colunas 2 a 2 e todas são linearmente independentes. Assim pelo
Teorema 2 temos que s – 1 = 2 ⇒ s = 3 ⇒ d = 3, ou seja, a distância mínima do
 d − 1  3 − 1
código C é 3, portanto este código corrige somente t =  = = 1 erro
 2   2 

c) Suponha que as seguintes informações são dadas: espaço = 00000

A = 10000 B = 01000 C = 00100 D = 00010 E = 00001

F = 11000 G = 10100 H = 10010 I = 10001 J = 01100
L = 01010 M = 01001 N = 00110 O = 00101 P = 00011
Q = 11100 R = 10110 S = 10101 T = 11001 U = 11001
V = 01110 X = 00111 Z = 11110

Decodifique as mensagens recebidas abaixo, admitindo que no máximo um erro é

introduzido em cada palavra transmitida.

c.1)

011001100 110010000 011111001 110010000

100100010 001100100 101101001 100110101
104 FAMAT em Revista - Número 06 - Maio de 2006

c.2)

001001011 110100101 111000001 001100000

000000000 110010001 111000001 001100100
011111001 000011010 110100101 011010110

c.3)

001100100 000110101 011001100 001100100

011111001 110100101 000000000 111110011
011011110 001101100 000000000 000011010
001100100 101101001 100111000 110010000
000000000 001010001 110100101 000110101
000011010 110010000 010101000 110100111

Para decodificar as mensagens faremos os seguintes procedimentos:

Código da fonte Palavra do código

Fonte A.G
A 10000 110010000

Transmissão

Procura
pelo líder
na tabela
Síndrome H.rt
c=r-e e de r r

Código da
fonte

Usuário
FAMAT em Revista - Número 06 - Maio de 2006 105

Acharemos as palavras do código.

FONTE CÓDIGO DA PALAVRA DO

FONTE CÓDIGO
Espaço 00000 Espaço . G 000000000
A 10000 A.G 110010000
B 01000 B.G 100100010
C 00100 C.G 111000001
D 00010 D.G 010101000
E 00001 E.G 001100100
F 11000 F.G 010110010
G 10100 G.G 001010001
H 10010 H.G 100111000
I 10001 I.G 111110100
J 01100 J.G 011100011
L 01010 L.G 110001010
M 01001 M.G 101000110
N 00110 N.G 101101001
O 00101 O.G 110100101
P 00011 P.G 011001100
Q 11100 Q.G 101110011
R 10110 R.G 011111001
S 10101 S.G 000110101
T 11010 T.G 000011010
U 11001 U.G 011010110
V 01110 V.G 001001011
X 00111 X.G 100001100
Z 11110 Z.G 111011011

Faremos a tabela do elemento líder e da síndrome

Líder (l) Síndrome (H . lt)

000000000 0000
000000001 0001
000000010 0010
000000100 0100
000001000 1000
000010000 1010
000100000 1111
001000000 1011
010000000 0111
100000000 1101
106 FAMAT em Revista - Número 06 - Maio de 2006

c.1)
011001100 110010000 011111001 110010000
100100010 001100100 101101001 100110101
t
Agora pegaremos a palavra recebida r e faremos H . r para acharmos a síndrome

r = 011001100 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra P

r = 110010000 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra A

r = 011111001 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra R

r = 110010000 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra A

r = 100100010 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra B

r = 001100100 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra E

r = 101101001 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra N

r = 100110101 ⇒ H . rt = (1101) ⇒ olhando na tabela e = (100000000) assim :

c=r–e
c = (100110101) – (100000000) = (000110101) que representa a letra S

A mensagem recebida no c.1 é PARABENS

c.2)

001001011 110100101 111000001 001100000

000000000 110010001 111000001 001100100
011111001 000011010 110100101 011010110

r = 001001011 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra V

r = 110100101 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra O
FAMAT em Revista - Número 06 - Maio de 2006 107

r = 111000001 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra C

r = 001100000 ⇒ H . rt = (0100) ⇒ ⇒ olhando na tabela e = (000000100) assim :

c=r–e
c = (001100000) – (000000100) = (001100100) que representa a letra E

r = 000000000 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa

espaço.

r = 110010001 ⇒ H . rt = (0001) ⇒ ⇒ olhando na tabela e = (000000001) assim :

c=r–e
c = (110010001) – (0000000001) = (110010000) que representa a letra A

r = 111000001 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra C

r = 001100100 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra E

r = 011111001 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra R

r = 000011010 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra T

r = 110100101 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra O

r = 011010110 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra U

A mensagem recebida no c.2 VOCÊ ACERTOU

c.3)

001100100 000110101 011001100 001100100

011111001 110100101 000000000 111110011
011011110 001101100 000000000 000011010
001100100 101101001 100111000 110010000
000000000 001010001 110100101 000110101
000011010 110010000 010101000 110100111
108 FAMAT em Revista - Número 06 - Maio de 2006

r = 001100100 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra E

r = 000110101 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra S

r = 011001100 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra P

r = 001100100 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra E

r = 011111001 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra R

r = 110100101 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra O

r = 000000000 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa

um espaço

r = 111110011 ⇒ H . rt = (0111) ⇒ olhando na tabela e = (010000000) assim :

c=r–e
c = (111110011) – (0100000000) = (101110011) que representa a letra Q

r = 011011110 ⇒ H . rt = (1000) ⇒ ⇒ olhando na tabela e = (000001000) assim :

c=r–e
c = (011011110) – (000001000) = (011010110) que representa a letra U

r = 001101100 ⇒ H . rt = (1000) ⇒ ⇒ olhando na tabela e = (000001000) assim :

c=r–e
c = (001101100) – (000001000) = (001100100) que representa a letra E

r = 000000000 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa

um espaço.

r = 000011010 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra T

r = 001100100 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra E

r = 101101001 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra N
FAMAT em Revista - Número 06 - Maio de 2006 109

r = 100111000 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra H

r = 110010000 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra A

r = 000000000 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa

um espaço.

r = 001010001 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra G

r = 110100101 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra O

r = 000110101 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra S

r = 000011010 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra T

r = 110010000 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra A

r = 010101000 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra D

r = 110100101 ⇒ H . rt = (0000) ⇒ nenhum erro ⇒ r = c este código representa a

letra O

A mensagem recebida no c.3 é ESPERO QUE VOCÊ TENHA GOSTADO

110 FAMAT em Revista - Número 06 - Maio de 2006

REFERÊNCIAS BIBLIOGRÁFICAS

[B] BLAHUT, Richard E., Theory and Practice of Error Control Codes, Addison-
Wesley, Reading, Massachusetts, 1984.

[G] GONÇALVES, A., Introdução à Álgebra, IMPA, Rio de Janeiro, 1979.

[H] HEFEZ, A. E VILLELA, M.L.T. , Códigos Corretores de Erros, IMPA, Rio de

Janeiro, 2002.

[L] LIPSCHUTZ, S., Álgebra Linear, MacGraw-Hill do Brasil , São Paulo,1981.

[MW] MACWILLIAMS, F.J., e SLOANE, N.J.A., The Theory of Error-Correcting

Codes, North-Holland, Amsterdã, 1992.