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.

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.

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.

Palavra código da fonte estimada

Palavra recebida

Palavra código do

canal

Palavra código da

fonte

Canal

Usuário

Demodulador

DecodificadorDo Canal

DecodificadorDa Fonte

Modulador

Codificador Do Canal

Codificador Da Fonte

Fonte

Sistema de Comunicação

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:

=

11101101100101100000

C

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

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} , como se segue: {0,1} x

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:

Codificador de canal

Codificador da fonte

fonte

UsuárioDecodificador

da fonte Decodificador

de canal

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:

=

11111011101001010101

C

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:

00 → 1010101 → 1001010 → 0111011 → 11111

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.

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 , para algum número natural n. O número de elementos de um

conjunto A será denotado por |A|. AAAAAn ××××= …

O código do robô é um subconjunto próprio de A5 , com A = {0 , 1}, onde A5 = ( ) ( ) ( ) ( ) ( )11111;......;00100;00010;00001;00000{ } e | = 25A | 5 = 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 é

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

==

)v.......,v(v)u,......,u(u

n,1

n1

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. Dados u, v, w ∈ An 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

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 . v)d(w, w)d(u, + 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 . v)d(w, w)d(u, + Assim somando todas as contribuições com i = 1,2,…,n , teremos que

. )v,w(d)w,u(d)v,u(d +≤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

Nesse caso A4 = } (1,1,1,1) , (1,1,0,1) , (1,0,1,1) , (0,1,1,1)

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

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)

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 = {(0,0,0) , (1,0,0) , (0,1,0) , (0,0,1) , (1,0,1) , (1,1,0) , (0,1,1) , (1,1,1)} 3F 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

Distância mínima d = 3 d ( 01011, 10110) = 4 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

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

Nesse caso, para calcular d é necessário calcular

2M

distâncias, onde M é o

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

distintas de C, então D(c,t) D (c’, t) = ∅ , onde t =∩

−

21d

Obs: [ * ] : parte inteira do número *

d(c,c’) ≥ d

2

)c'd(c,

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

corrigir até t =

−

21d

erros. Se d é par, o código pode simultaneamente corrigir

22−d

erros e detectar até 2d

erros.

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

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.

Agora se d for par, então

−

21d =

22−d . Conseqüentemente, C pode

corrigir 2

2−d erros. Mas, se 2d

ocorreu, isso significa que a palavra recebida r tem

d(c,r) = 2d . Se existe alguma palavra c’ ∈ C tal que d(c,c’) = d , teremos que r pode

estar no “ponto médio” entre c e c’, Nesse caso, d(c’,r) =2d

e o decodificador pode

detectar que 2d

erros ocorreram, mas não pode corrigi-los pois existem duas

possibilidades distintas c e c’ para efetuar a decodificação pela vizinhança mais próxima.

2

d

2

dt

t r

Por outro lado, se mais de 2d erros ocorrem, a palavra recebida r pode estar mais

próxima de outra palavra do código que não a correta.

d

d(c,r) > 2

d

e d(c’,r) < t

t r

t

2

d 2

d

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

Por exemplo em um código com d = 4, é possível corrigir até t =

−

21d

= 1 erro e

detectar até 2d

= 2 erros. Note que pelo teorema anterior, um código terá maior

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.

Definição 1.4: Seja C ⊂ An um código com distância mínima d e seja t =

−

21d

. O

código C será dito perfeito se ∪Cc

nAtcD∈

=),(

Exemplos: 1 – O código do robô não é perfeito, pois ele é um código C A⊂ 5 , 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

∪Cc

AcD∈

≠ 5)1,(

2 – Todo código de Hamming é perfeito (falaremos deste tipo de código no capítulo II)

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

. MlogqlogqlogCdim qqq ==== kkk

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).

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: 42

22 FF →

(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) }

Além disso, w(C) = 2 e C corrige t =

−

21d

= 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 é ,

G =

=

knkk

n

n

k vvv

vvvvvv

v

vv

.....................

.....

.....

.

.

21

22221

11211

2

1

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:

G =

01101001

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.

(0,0) . G = ( ) ( 000001101001

.00 =

)

)

(1,0) . G = ( ) ( 100101101001

.01 =

(0,1) . G = ( ) ( 011001101001

.10 =

)

)

(1,1) . G = ( ) ( 111101101001

.11 =

Fonte Palavra

código Da fonte

Palavra código

Do canal Para frente 00 0000 Par trás 01 0110 Para direita 10 1001 Para esquerda 11 1111

Codificador

da fonte Codificador

do canal

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.

[ ]AId=*G k

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

=

0101010110000100110010000111

G

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

7c6c5c4c3c2c1c

4L3L2L1L

0101010110000100110010000111

0111000110010000011100010101

c7 ↔ c3 ≈

c3 ↔ c1 c5 ↔ c2 ≈

0111000110010010010101010001

=

0111000110010011100101010001

[ ]A4Id onde,

L4 + L2 ≈

4x41000010000100001

4Id

=

=

kxk

e

34)(011110111101

xknkx

A

=−

=

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 =vu, u1v1+u2v2+....+unvn . Essa operação possui as seguintes propriedades usuais de um produto interno, ou seja, é simétrica :

uv,vu, = e bilinear vw,λvu,vλw,u +=+ ∀ λ ∈ F

Definição 2.7: Seja C ⊂ Fn um código linear. Define-se C⊥ = { }Cu,0u,v:Fv n ∈∀=∈ . 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:

0λ00wv,λwu,wλv,u =+=+=+ . Portanto u + λv ∈ C⊥ , provando que C⊥ é um subespaço vetorial de Fn . (ii) v∈ C⊥ ⇔ v é ortogonal a todos os elementos de C ⇔ 0uv, = ∀ u ∈ C ⇔ v é ortogonal a todos os elementos de uma base de C ⇔ Para uma base β = {u1,u2,....,uk}de

C, 0iuv, = ; i = 1,2,..,k , o que é equivalente a dizer que:

( ) 0v,ku,....,v,2u,v,1u = ⇔ Gvt = 0 , pois todas as linhas de G são elementos 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 = ( )AIdk . Então: (i) dim C⊥ = n – k (ii) H = ( )kn−− IdtA é 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:

x10

0

nx1nv

1v

.

xn,na1a|1000|01|00

2,na12,a|000101,na11,a|00001

kkkkk,

kk

=

+

+

+

Daí:

⇒

=++++

=++++

=+++++

0n.vna1.v1av

0n.v2,na1.v12,a2v0n.v1,na1.v11,a1v

k,kkk,k

kkkk

( )( )

( )

++

−=

⇒

++++−=

++++−=

++++−=

⇒

nv

2v1v

.A

v

2v1v

n.vna......1.v1av

n.v2,na......1.v12,a2vn.v1,na......1.v11,a1v

kk

kk,kkk,k

kk

kk

Logo temos que: v = (v1,v2,..,vn) =

( n21nn,11,nn2,112,nn1,111, v,..,v,v),.va....v(a...,),.va....v(a),.va....v(av ++++++++ ++−++−++−= kkkkkkkkkk

( ) ( ),1,0,0,0,...a,....,a,av......,1,0,...,0a,....,a,avv n,n2,n1,n1,12,11,1 kkkkkk −−−++−−−= ++++ 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

H, denotada por Hi ; 1 ≤ i ≤ n – k, será e a j-ésima

),0,...00,0,....,1,a,...,a,a(Helementosnelementos

i2i1ii

kk

k

−

−−−=

Posição i

linha de G, denotada por Gj ; 1 ≤ i ≤ k , será Gj =

−

−

elementosn

nj,j2j1

elementos

a,...,a,a,0,..0,00,0,...,1,k

k

k

Posição j Daí, ji G,H = -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.

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 = ij H,G , 1≤ j ≤ k e

1≤ i ≤ n – k que é equivalente a fazer o produto , ou seja, D = G.Htk)nx(nkxn .HG −

t . 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

G = . Determine se o vetor v = (1010101) ∈ pertence a

C.

011|1000110|0100111|0010101|0001

72F

Nesse caso, temos A = e –A

011110111101

t = e daí

H = . Além disso,

011111101011

0111|1001110|0101011|001

H.vt = Cv001

1111

111

1010101

.011110011100101011001

7x1

3x7

∉∴

=

++++

=

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.

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.

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 ⇒

0h)(hhn

1ii

'ii

n

1ii

'i

n

1iii =α−α⇒α=α ∑∑∑

===

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

linear , o que nos dá uma relação de dependência linear entre m

colunas de H com m ≤ 2t ≤ d – 1 . Como quaisquer d – 1 colunas de H são linearmente independentes, temos que α

0h)(n

1ii

'ii =α−α∑

=

i – α’i = 0 ⇒ αi = α’i , ∀ i = 1,...,n . Portanto, e = e’. O problema que devemos resolver agora é determinar esse único vetor e a partir de Hrt . 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 – n

FvF)Cv(

n

=+∈∪

5 - |(v + C)| = |C| = qk

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

número de classes laterais segundo C é knk

nq

qq −= .

Exemplo: Seja C o código gerado sobre F2 pela matriz G = . Logo,

10101101

=11011000

1110,0101,1011,0000C

42F

e as classes laterais segundo C são: qn-k = 24 – 2 = 4

classes. Como 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

que w(u) ≤

−

21d = t então u é o único elemento líder de sua classe.

Demonstração:

Suponhamos u,v ∈ Fn com

−

≤2

1d)u(w e

−

≤2

1d)v(w

∈−=−=⇒+∈=⇒+∈

CccvyvCyyuCy

21

. Se u e v são

elementos da mesma classe, então u – v ∈ C , pois . Nesse

caso,

++

ucvcu

2

1

1−d2

1d2

1d)v(w)u(w)vu(w ≤

−

+

−

≤−≤− . Como w(a) ≥ d , ∀ a ∈ C ≠ 0,

temos que, u – v = 0 ⇒ u = v. Portanto, para encontrarmos os líderes de classes, tomamos os elementos u ∈ Fn

tais que t2

1d)u(w =

−

≤ . Cada um desses elementos é líder de uma e somente uma

classe.

Os líderes de classe v tais que t2

1d)v(w =

−

≥ não serão considerados na

correção de erros.

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

sofrido um número de erros menor ou igual a

−

=2

1dt .

* 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

. Note que 3 = n – k , como n = 6, então k = 3. Além disso,

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 F com w(u) ≤ 1 e suas respectivas síndromes estão relacionados na tabela abaixo:

=

110100011010101001

H

62

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,

( ) ( ) ( )110011010000100011 =−=−= erc

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 { }0\Fm

2 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.

Como no exemplo numérico, considere a matriz .

Essa é a matriz de um código de Hamming correspondente a m = 3.

=

100111001010110011101

H

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

No nosso caso 12

1t =

−

=d . Dado c em F , temos que n

2 n1)1,c(D += . Portanto,

[ ] [ ] nmnmk

Cc

22.1212.n1)1,c(D =−+=+= −

∈∪ e conseqüentemente ∪ . n

2Cc

F)1,c(D =∈

CAPÍTULO III

EXEMPLO DE UM CÓDIGO LINEAR Considere o código binário C com matriz geradora

.

=

001001100000101010100000111010001001000010011

G

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.

24

21

13

12

kxn

LL

LL

001001100000101010100010100010011010000010011

LLLL

001001100000101010100000111010001001000010011

G+≈

+

≈++

=

54

35

LL101011000010110000100010100010011010010001001

LL001001100010110000100010100010011010010001001

+≈

+

≈

≈

≈++

+

≈

≈42

41

45

LLLL

010110000111101000100010100010011010010001001

LL101011000111101000100010100010011010010001001

( )4x5553

52

A|IdG

010110000111101000110100100111000010101100001

LLLL

010110000111101000100010100101110010101100001

=

≈++

≈

( ) ( )

=

=−=−= −

100001111010011110001001011000111101

1000|011110100|111100010|010110001|11101

Id|AId|AH 4t

knt

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

código C é 3, portanto este código corrige somente erro12

132

1dt =

−

=

−

=

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

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:

Fonte A

H . r t

Código da fonte

c = r - e e

Procura pelo líder na tabela

Síndrome de r r

Transmissão

Palavra do código

110010000 A . G

Código da fonte

10000

Usuário

Acharemos as palavras do código.

FONTE CÓDIGO DA FONTE

PALAVRA DO 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

c.1) 011001100 110010000 011111001 110010000 100100010 001100100 101101001 100110101

Agora pegaremos a palavra recebida r e faremos H . rt 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

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

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

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

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.