8. sistemas para deteção/correção de erros

Departamento de Engenharia Elétrica Faculdade de Tecnologia

Universidade de Brasília Tel. (061)273-5977 - Fax. (061)274-6651

ENE - UnB

INFORMAÇÃO, CODIFICAÇÃO E SEGURANÇA DE DADOS

Prof. Joel G. Silva Filho e-mail: [email protected]

8.1

8. SISTEMAS PARA DETEÇÃO/CORREÇÃO DE ERROS

8.1 Introdução

No capítulo anterior estabelecemos as bases que possibilitam a construção de códigos

detetores/corretores de erro, e estabelecemos uma estrutura genérica para duas importantes classes

gerais de códigos: os códigos lineares e os códigos polinomiais. No presente capítulo vamos nos

aprofundar nessas estruturas e analisar alguns dos códigos mais utilizados destas classes.

8.2 Implementação de Códigos Lineares

Um código linear C de comprimento n é dito ser linear se: C é um sub-espaço de Vn(q) e,

sendo este sub-espaço de dimensão k, então temos um código (n, qk,d). Além disso, as qk palavras-

código de C podem ser descritas por apenas k palavras-código linearmente independentes.

Esta última característica de um código linear é a grande vantagem que esta classe de

códigos possui sobre um código genérico qualquer, ou seja, não é preciso armazenar todo o

dicionário do código, pois, a partir de apenas k palavras-código podemos obter qualquer outra

palavra-código.

Como vimos no capítulo anterior, podemos ver o processo de codificação em um código

linear como uma transformação linear aplicada ao vetor informação, transformação esta descrita

por uma matriz geradora do código, G, a qual tem dimensão k x n, e cujas linhas são constituídas

por aqueles k vetores-código de C linearmente independentes.

Dada uma matriz geradora para C, G, uma transformação sobre G envolvendo

�� permutação de linhas ou colunas;

�� multiplicação escalar de uma linha ou coluna por � � 0, � � GF(q);

�� soma a uma linha (coluna) de um múltiplo escalar de outra linha (coluna);

resulta em uma matriz G’, tal que o código C’, gerado por G’, é um código equivalente a C.

Baseado nas propriedades acima, é simples se verificar o seguinte lema: Se G é uma matriz geradora para C, então é possível se encontrar G’, geradora de C’, equivalente a

C, tal que

Departamento de Engenharia Elétrica Faculdade de Tecnologia Universidade de Brasília Tel. (061)273-5977 - Fax. (061)274-6651

ENE - UnB



8.2

G’ = [Ik,A]

onde Ik é uma matriz identidade de dimensão k.

Define-se o peso de um vetor x, w(x), como o número de elementos não-nulos contidos em

x. Desta forma, podemos definir a distância mínima de C, d, como o peso mínimo de seus vetores

não-nulos, visto que o vetor 0 sempre será um vetor-código.

8.2.1 Processo Geral de Codificação

Podemos visualizar a matriz geradora G como

G =

gg

g

1

2

�

k

�

�

��

�

�

��

= [Ik,A], A: k x (n-k)

e, uma palavra-código pertencente a C será dada por

Eq. 8.1 C = a a qi ii

k

ig�

� ��

��

��

��0, GF( )

Dado o vetor-informação D = [d1, d2, ... , dk ], o vetor-código V = [v1, v2, ... , vn] será obtido

como

Eq.8.2 V = DG, v dv vi i

k n

i k� � �

�

��

,[ , . . . , ] DA

1

1

Como ilustração, repetimos aqui o exemplo da seção 7.10.4, onde tínhamos

G �

�

�

��

�

�

��

1 0 0 0 1 0 10 1 0 0 1 1 10 0 1 0 1 1 00 0 0 1 0 1 1

, e tendo-se, então, A �

�

�

��

�

�

��

1 0 11 1 11 1 00 1 1

, sobre GF(2).

Dado um vetor informação I = [1,0,0,0] obtemos V = IG = [1,0,0,0,1,0,1] como vetor-

código.

8.2.2 Decodificação por Máxima Semelhança

Pode-se verificar que, para V uma palavra ou vetor-código, então devemos ter

[-AT, In-k]VT = 0

onde a matriz

Eq.8.3 H = [-AT, In-k]



ENE - UnB



8.3

é a matriz verificadora de paridade, visto que, para verificarmos se dada palavra recebida R

é uma palavra-código, isenta de erros portanto, satisfaz

Eq.8.4 RHT = 0 = HRT

O processo de codificação de uma mensagem utilizando um código linear envolve a

expansão da palavra de k-bits de informação em um vetor-código de n-bits através o uso da

matriz geradora do código. O vetor assim formado é então transmitido através um canal de

informação, onde estará sujeito a ruído, e pode portanto ser corrompido pelo ruído. Pode-

mos interpretar o efeito do ruído no canal como o da adição de um vetor-erro, E = [e1, e2,

e3,..., en], ao vetor-código transmitido. Os componentes individuais do vetor erro, ei, indi-

cam a magnitude do erro na i-ésima posição do código. No caso de estarmos trabalhando

sobre GF(2), um sistema binário portanto, teremos ei � {0,1}, e somente um tipo de erro é

possível, em cada posição. A palavra recebida, R = [r1, r2, r3,..., rn], claramente está

relacionada ao vetor transmitido e vetor-erro no canal através

Eq. 8.5 R = V + E, sobre GF(q)

ou, [r1, r2, r3,..., rn] = [v1, v2, v3,..., vn] + [e1, e2, e3,..., en]

= [v1+e1, v2+e2, v3+e3,..., vn+en].

O problema da decodificação está em encontrarmos o V mais provável de ter sido transmi-

tido, dado um R recebido. Na recepção, computamos então a síndrome S, a qual é definida

por

Eq. 8.6 S = RHT, ou ST = HRT

onde S = [s1, s2, s3,..., sr], r = (n-k) sendo o número de símbolos de redundância (checks de

paridade) introduzidos na codificação.

Seguindo-se com o exemplo anterior, temos

H �

�

�

��

�

�

��

1 1 1 0 1 0 00 1 1 1 0 1 01 1 0 1 0 0 1

, e sss

rrrrrrr

1

2

3

1

2

3

4

5

6

7

1 1 1 0 1 0 00 1 1 1 0 1 01 1 0 1 0 0 1

�

�

��

�

�

��

�

�

�

��

�

�

��

�

�

��

�

�

��

Assim, os dígitos da síndrome são descritos exatamente pelas mesmas equações que definen

as checagens de paridade. A síndrome revela portanto onde falhou a checagem de paridade


ENE - UnB



8.4

no vetor recebido. Para podermos corrigir os erros precisamos deduzir qual o padrão de erro

mais provável de ter ocorrido, de forma a podermos recuperar o vetor transmitido como

Eq. 8.7 V = R - E.

Sabemos que o conjunto de palavras-código devem satisfazer HVt = 0. Assim, devemos ter

Eq. 8.8 H(R - E)T = 0 = HRT - HET

o que implica em

Eq. 8.9 HRT = HET = ST,

e portanto, o conjunto dos possíveis vetores de erro é o conjunto daqueles vetores que têm a

mesma síndrome que o vetor recebido R. Um tal conjunto é um subconjunto do total de

vetores possíveis, de n-dígitos, dito ser um coset daquele. O coset com síndrome 0 é

formado precisamente pelo conjunto de palavras-código, isto é, o dicionário do código.

Utilizando o princípio da máxima semelhança, decidiremos que o padrão de erro mais

provável é aquele membro do coset do vetor recebido que apresenta o menor número de

componentes não-nulas. O elemento de um coset que apresenta o menor número de

componentes não-nulas é dito ser o líder do coset. Assim, o vetor de erro mais provável é o

líder do coset que contém o vetor recebido.

Podemos agora estabelecer uma técnica geral para a decodificação. O total de qn vetores

possíveis é particionado em qr cosets de qk membros cada, cada coset associado a uma

possível síndrome particular. O coset com síndrome zero forma o dicionário do código. Na

recepção, tudo que temos que fazer é computar a síndrome do vetor recebido, identificar o

líder do coset corres-pondente a esta síndrome, e subtraí-lo do vetor recebido para obtermos

o vetor mais provável de ter sido transmitido. Obviamente este vetor pertence ao dicionário

do código. Considerando ainda o caso do exemplo anterior, para n=7, k=4 e r=3, sobre

GF(2), podemos obter a tabela de cosets apresntada na Tabela 8.1.

Suponha que tenha sido transmitido o vetor V = [1,0,0,0,1,0,1], e tenhamos recebido R =

[1,0,1,0,1,0,1]. Computando-se a síndrome de R obtemos S = [1,1,0]. O líder do coset

correspondente a esta síndrome, o mais provável vetor de erro, a partir da Tabela 8.1 é E =

[0,0,1,0,0,0,0]. Recuperamos portanto V’ como V’ = R - E = V, sobre GF(2). Se, ao invés,

tivermos transmitido o vetor V, e, ocorrendo 2 erros, recebermos o vetor R’ =

[1,1,0,1,1,0,1], computando-se a síndrome encontramos S’ = [1,0,0], o que correponde ao

líder do coset E’ = [0,0,0,0,1,0,0]. Isto nos levaria a deduzir, erroneamente, que o vetor

transmitido foi V’ = [1,1,0,1,0,0,1] � V. Tal fato deve-se a que, pelo princípio da máxima



ENE - UnB



8.5

semelhança, assumimos que 1 erro é mais provável que dois, e corrigimos o vetor recebido

baseado nesta suposição: se houve erro, então foi um erro simples.

Tabela 8.1: Tabela de Cosets para Código (7,4,3) sobre GF(2).

S=[0,0,0] S=[1,0,0] S=[0,1,0] S=[1,1,0] S=[0,0,1] S=[1,0,1] S=[0,1,1] S=[1,1,1]0000000 0000100 0000010 0010000 0000001 1000000 0001000 0100000 1011000 1110000 1100000 1001000 0110000 0011000 1010000 1111000 1110100 0101000 0111000 1100100 1101000 0110100 0100100 1010100 0101100 1011100 0010100 0111100 1000100 1101100 1111100 0001100 1100010 0010010 1001100 1110010 0011100 0100010 0110010 1000010 0111010 1001010 1011010 0101010 1010010 1111010 1101010 0011010 0010110 1100110 1110110 0000110 0001010 1010110 1000110 0110110 1001110 0111110 0101110 1011110 0100110 0001110 0011110 1101110 0110001 1000001 1010001 0100001 1111110 1110001 1100001 0010001 1101001 0011001 0001001 1111001 1011001 0101001 0111001 1001001 1000101 0110101 0100101 1010101 1110101 0000101 0010101 1100101 0011101 1101101 1111101 0001101 0101101 1011101 1001101 0111101 1010011 0100011 0110011 1000011 1100011 0010011 0000011 1110011 0001011 1111011 1101011 0011011 0111011 1001011 1011011 0101011 0100111 1010111 1000111 0110111 0010111 1100111 1110111 0000111 1111111 0001111 0011111 1101111 1001111 0111111 0101111 1011111

O problema para a montagem de um código linear agora fica:

i. como deduzimos a matriz G (H) necessária para gerar o código?

ii. como deduzimos, a partir da síndrome, o líder do coset?

8.3 Código de Hamming como um Código Linear

Já tivemos oportunidade de examinar uma construção de um código de Hamming, e já deve

ter sido notado que o código de Hamming é um caso particular de um código de bloco linear.

Códigos de Hamming são códigos de alta taxa, com uma estrutura bastante simples, mas eficiente

para a correção de erros simples.

Já vimos que podemos obter a síndrome como ST = HET, o que, no caso do exemplo que

temos utilizado, corresponderia a

� �sss

r r r r r r r T1

2

3

1 2 3 4 5 6 7

1 1 1 0 1 0 00 1 1 1 0 1 01 1 0 1 0 0 1

�

�

��

�

�

��

�

�

�

��

�

�

��

, ou

e portanto verificamos que a síndrome corresponde à soma daquelas colunas de H correspondentes

às posições dos erros. Se qualquer coluna de H for nula, obviamente ela não contribui em nada para

a síndrome, e assim um erro nesta posição não poderá ser detetado. Também, se duas ou mais


ENE - UnB



8.6

colunas forem idênticas, não saberemos distinguir a qual posição corresponde o erro, e não seremos

capazes de corrigí-lo. Portanto, um código de grupo, linear, somente será capaz de corrigir erros

simples se todas as colunas da matriz H forem distintas e não-nulas. Assim sendo, obtemos uma

síndrome única para cada posição de erro possível de ocorrer. Se a síndrome for nula, assumimos

que não ocorreram erros. Se a síndrome for não-nula, o decodificador deve supor que ocorreu um

erro simples na posição correspondente à coluna de H igual à síndrome.

Se temos r-bits de paridade, e portanto r-bits na síndrome, e r linhas na matriz H. Temos

assim que o número de colunas não-nulas distintas que podemos ter em H é 2r-1, o que nos leva a

que o comprimento máximo da palavra-código será 2r-1. Supondo-se que utilizaremos o compri-

mento máximo para as palavras-código, as colunas de H serão constituídas de todas as combinações

não-nulas de r-bits, tomadas em qualquer ordem. Esta estrutura caracteriza um Código de

Hamming, generalizado. Para todo valor de r � 1 existe um código de Hamming com r-bits de

paridade, com comprimento da palavra de n = 2r-1 bits, dos quais k = n - r são bits de informação. A

taxa do código é

Eq. 8.10 R kn

r rr

r r� �

� �

�

� �

�

2 12 1

12 1

.

Embora possamos alocar as colunas de H em qualquer ordem, é vantajoso que atribuamos às

mesmas uma codificação tal que a síndrome indique diretamente a posição do erro, ou seja,

codificamos as colunas de H na sequência natural dos números binários, iniciando em ‘1’. Assim,

para nosso código anterior, a matriz verificadora H torna-se

e, para termos HVt = 0, então uma palavra código deverá ser tal que

v1 + v3 + v5 + v7 = 0

v2 + v3 + v6 + v7 = 0 sobre GF(2)

v4 + v5 + v6 + v7 = 0

o que é exatamente o mesmo resultado obtido na seção 7.9, quando ainda não visualizávamos o

código de Hamming como um código linear.

Embora, em princípio, possamos colocar os bits de paridade em qualquer posição dentro da

palavra-código, é desejável que os mesmos sejam independentes uns dos outros, o que, neste caso,



ENE - UnB



8.7

somente é possível se fizermos c1 = v1, c2 = v2 e c3 = v4. Em geral, temos que ci ocupará a posição

de v2 1i � . Teremos portanto que a palavra-código será formada como apresentado na figura 8.1.

figura 8.1: Formato da palavra-código em um Código de Hamming.

No caso geral, podemos identificar o líder do coset correspondente a dada síndrome, não

nula, como aquele vetor que possui um único componente não-nulo na posição correspondente à

coluna de H idêntica à síndorme obtida. No exemplo da seção anterior, a síndrome S = [1,1,0]

corresponde à terceira coluna da matriz H lá utilizada, levando-nos a deduzir que o vetor de erro

mais provável seja E = [0,0,1,0,0,0,0], como efetivamente também foi lá deduzido, utilizando-se da

tabela de cosets.

8.4 Códigos Cíclicos ou Polinomiais

Um código cíclico é um código linear que apresenta a propriedade de toda palavra código

poder ser obtida como uma rotação cíclica de outra palavra código, ou seja

V = [v0, v1, ... , vn-1] � C � V’ = [vn-1, v0, v1, ... , vn-2] � C

Neste caso, torna-se adequado utilizarmos uma representação polinomial sobre GF(q) para

um vetor-código, na forma

v(x) = v0 + v1x + v2x2 + ... + vn-1xn-1

Denomina-se de polinômio gerador do código ao polinômio mínimo em GF(q), pertencente

a C, e relacionado à matriz geradora G, tal que,

g(x)h(x) = (xn-1)

sendo h(x) denominado o polinômio recursivo do código. Também,

� v(x) � C � v(x) = q(x)g(x) mod-(xn-1) para algum q(x) de grau menor que n.

Assim, em um código cíclico, ou polinomial, toda palavra-código, aqui denominada de

polinômio código, é um múltiplo do polinômio gerador g(x), módulo-(xn-1).

Efetivamente, podemos então observar que, sendo v(x) uma palavra código, então

x.v(x) mod-(xn-1) = x.v(x) mod-g(x)h(x)

= vn-1+v0x+v1x2+ v2x3+...+vn-2xn-1


ENE - UnB



8.8

= q’(x)g(x) mod-(xn-1)

sendo também uma palavra código, a qual constitui uma rotação cíclica de v(x), e assim

assegurando que todas as rotações cíclicas de uma palavra código constituem também palavras

códigos, justificando a designação dessa classe de códigos de códigos cíclicos.

Para um código (n,k), o polinômio gerador toma a forma geral

g(x) = 1 + g1x + g2x2 + ... + gn-k-1xn-k-1

e, para um vetor informação dado por (em forma polinomial)

d(x) = d0 + d1x + d2x2 + ... + dk-1xk-1,

o processo de codificação consiste em construirmos

Eq. 8.11 v(x) = xn-k d(x) - p(x),

= xn-k d(x) + p(x), sobre GF(2m)

onde

Eq.8.12 xn-k d(x) = q(x)g(x) + p(x),

ou seja, dividimos o polinômio xn-k d(x) por g(x), obtendo um polinômio quociente q(x) e um

polinômio resto p(x). Portanto, podemos reescrever v(x) como

v(x) = q(x)g(x) + p(x) - p(x) = q(x)g(x),

assegurando portanto que v(x) é um múltiplo de g(x).

Assim sendo, podemos reescrever uma expressão geral para v(x) como

v(x) = - p0 - p1x - p2x2 + ... - pn-k-1xn-k-1 + d0xn-k + d1xn-k+1 + ... + dk-1xn-1

= v0 + v1x + v2x2 + ... + vn-k-1xn-k-1 + vn-kxn-k + vn-k+1xn-k+1 + ... + vn-1xn-1, Eq.8.13

onde os dígitos pi (vi), 0 i n-k-1, correspondem aos (n-k) dígitos de checagem de paridade, e os

dígitos di, (vn-k+i), 0 i k-1, correspondem aos k dígitos de informação.

Podemos encontrar, de forma sistemática, a matriz geradora do código G dividindo-se xn-k+i

por g(x), tal que

xn-k+i = qi(x) g(x) + pi(x), 0 i k-1

ou vi(x) = pi(x) + xn-k+i 0 i k-1

resultando em v(x) = v ( )ii

kx

�

�

�0

1, múltiplo de g(x), visto que cada vi(x) o é, para cada i.

Arranjando-se estes k vetores códigos (polinômios) em uma matriz k n obtemos então a

matriz G como



ENE - UnB



8.9

G

, , ,

, , ,

, , ,

�

�

�

��

�

�

��

� �

� �

� � � � �

p p pp p p

p p p

0 0 0 1 0 1

1 0 1 1 1 1

1 0 1 1 1 1

1 0 00 1 0

0 0 1

�

�

� � � �

�

�

�

� � � �

�

n k

n k

k k k n k

Eq.8.14

onde pi,j representa o j-ésimo coeficiente do polinômio pi(x), e o processo de codificação agora fica,

visto como um código linear,

V = [v0, v1, v2, ... , vn-1]

= DG = [d0, d1, ... , dk-1]

gg

g

0

1

1k�

�

�

��

�

�

��

O processo de codificação, na forma polinomial, pode então ser estabelecido através os

seguintes passos:

i. multiplique o polinômio informação, d(x), por xn-k, obtendo xn-k d(x);

ii. divida o polinômio assim obtido por g(x), obtendo um resto p(x);

iii. obtenha o polinômio-código v(x) como a soma

v(x) = xn-k d(x) - p(x),

ou v(x) = xn-k d(x) + p(x), sobre GF(2m).

8.5 Códigos BCH

Os códigos BCH, cujo nome se origina do nome de seus criadores - Bose, Chaudhuri e

Hocquenghen, formam uma subclasse dos códigos cíclicos ou polinomiais, sendo portanto, também,

códigos lineares. Consideraremos aqui códigos BCH binários, sendo a extensão para códigos não

binários um processo direto, substituindo-se GF(2) por GF(q) e GF(2m) por GF(qm).

O polinômio gerador do código, g(x), é dado pelo produto dos polinômios mínimos distintos

de �i, mi(x), 1 i 2t, � um elemento primitivo de GF(2m). Agora, se v(x) é uma palavra código,

então v(x) é divisível por mi(x), e, portanto, �, �2, ... , �2t são raízes de v(x) em GF(2m). Assim,

g(x) = mmc{m1(x), m2(x), ... , m2t(x)}. Como sabemos que as potências pares de �, � 2k i ,

comungam de um mesmo polinômio mínimo, mi(x), podemos reduzir a expressão para g(x) a


ENE - UnB



8.10

Eq. 8.15 g(x) = m xii

t

2 11

�

�

� ( ) .

Como mi(x) tem grau não superior a m, então o grau de g(x) será r mt, resultando em um

código de características

�� n - comprimento do código;

�� t - capacidade de correção;

�� r mt - número de bits de redundância.

�� k = (n - r) - número de bits de informação;

Um tal código é dito ser um código (n,k,t), e o processo de codificação assume a forma geral

para códigos polinomiais, como visto na seção anterior.

Exemplo 1:

Construir o código BCH (15,7,2). Temos n = 15, e portanto m = 4, tal que (2m -1) = 24 -1 =

15; k = 7, r = (n - k) = 8, e t = 2. Considerando que GF(16) é gerado pelo polinômio (x4 + x

+ 1), primitivo em GF(2), conforme descrito no Anexo I, então devemos ter

g(x) = m1(x) m3(x)

com

m1(x) = 1 + x + x4

m3(x) = 1 + x + x3 + x4

e assim

g(x) = 1 + x4 + x6 + x7 + x8.

Fazendo-se agora x8+i = qi(x)g(x) + pi(x), obtemos a matriz geradora, dada por

G =

1 0 0 0 1 0 1 1 1 0 0 0 0 0 01 1 0 0 1 1 1 0 0 1 0 0 0 0 00 1 1 0 0 1 1 1 0 0 1 0 0 0 01 0 1 1 1 0 0 0 0 0 0 1 0 0 00 1 0 1 1 1 0 0 0 0 0 0 1 0 00 0 1 0 1 1 1 0 0 0 0 0 0 1 00 0 0 1 0 1 1 1 0 0 0 0 0 0 1

�

�

��

�

�

��

.

Podemos agora codificar um vetor informação D como V = DG. Por exemplo, se

D = [ 1 0 0 0 0 0 0 ], então V = [ 1 0 0 0 1 0 1 1 1 0 0 0 0 0 0 ],

ou, em forma polinomial, d(x) = 1, e, v(x) = g(x) = 1 + x4 + x6 + x7 + x8.



ENE - UnB



8.11

Como as potências �i, 1 i 2t, são raízes de v(x), deveremos ter

v(�i) = v0 + v1�i + v2�

2i + ... + vn-1�(n-1) i = 0

ou, em forma matricial,

[v0, v1, v2, ... , vn-1]

�

�

�

�

0

2

1

ii

n i�

( )�

�

�

��

�

�

��

= 0, 1 i 2t.

Podemos observar ser esta exatamente a expressão para a checagem de paridade, o que nos

leva à forma da matriz H, que pode então ser dada por

Eq.8.16 H = � � � � � � � �� i i i i n0 1 2 1�

��

��

��, 1 i 2t,

ou, expandindo, para todo i,

Eq.8.17 H =

� � � ��

� � � �

11

111

2 1

2 2 2 2 1

3 3 2 3 1

2 2 2 2 1

� � �

� � �

� � �

� � �

�

�

�

� � � �

�

nn

n

t t t n

�

�

�

�

�

�

��

�

�

��

formando um matriz (2t n) onde cada elemento de H é um elemento de GF(2m). Porém, tal como

para o polinômio gerador, sendo �i uma raiz de mi(x), �2 k i é uma raiz conjugada de �i, sendo

também raiz de mi(x), e portanto as linhas de potências pares na matriz H podem ser omitidas. Se

codificarmos agora cada uma das potências de � em H como a correspondente m-upla de GF(2),

utilizando a forma vetorial para os elementos de GF(2m), na forma de um vetor coluna, obteremos a

forma binária da matriz, neste caso, uma matriz (2mt n).

Exemplo 2: Considerando ainda o código BCH (15,7) do exemplo anterior, teremos,

H = � �

11

2 14 14

3 6 12 14 3� � � �

� � � �

�

�

�

�

�

�

��

�

�

��

ou, em forma binária,


ENE - UnB



8.12

H =

1 0 0 0 1 0 0 1 1 0 1 0 1 1 1 0 1 0 0 1 1 0 1 0 1 1 1 1 0 0 0 0 1 0 0 1 1 0 1 0 1 1 1 1 0 0 0 0 1 0 0 1 1 0 1 0 1 1 1 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 0 1 1 0 0 0 1 1 0 0 1 0 1 0 0 1 0 1 0 0 1 0 1 0 1 1 1 1 0 1 1 1 1 0 1 1 1 1

�

�

��

�

�

��

8.5.1 Determinação da Síndrome

Sendo v(x) o polinômio-código transmitido e r(x) o polinômio código-recebido, para

decodificar r(x), precisamos computar a síndrome s(x), a partir de r(x). Para um código

corretor de t erros, a síndrome tem 2t elementos:

S = [s1, s2, ... , s2t] = RHT, sobre GF(2m),

onde H é dado pela Eq.8.17. Podemos utilizar também a versão simplificada de H,

computando os valores s2i-1, 1 i t, e obtendo os demais elementos, de índices pares, como

s k j2 = sj, k = 1,2,... e j = 1,3,...,2t-1.

Tendo ocorrido erro na transmissão, representado por um vetor-erro E = [e0,e1,...,en-1], ou, em

forma polinomial por e(x) = e0 + e1x + e2x2 + ... + en-1xn-1, podemos expressar o polinômio

(vetor) recebido como

Eq.8.18 r(x) = v(x) + e(x).

Suponha agora que � erros ocorreram, com � t. Sejam as posições dos erros dadas por j�, 1

� �, tal que podemos escrever

Eq.8.19 e(x) = x j�

�

�

�

�1

,

e 0 j� (n-1). Como �i, 1 i 2t é raiz de v(x), então podemos reescrever a Eq.8.18 como

Eq.8.20 r(�i) = e(�i), 1 i 2t.

De outra forma, computamos os elementos da síndrome dividindo o polinômio recebido, r(x),

por mk(x), 1 k 2t, tal que

Eq.8.21 r(x) = qk(x)mk(x) + ��k(x)

onde ��k(x), para x = �k, é o elemento sk da síndrome, visto que mk(�k) = 0. Temos portanto

que os componentes da síndrome podem ser expressos como

Eq.8.22 sk = k = r(�k) = e��

�� 1 k 2t.



ENE - UnB



8.13

Exemplo 3:

Considere um código BCH (15,7,2), como anteriormente. Suponha v(x) = 0, e suponha ainda

que foi recebido r(x) = x6 + x11. Claramente ocorreram 2 erros, e, como 2t = 4, a síndrome

tem 4 elementos: S = [s1, s2, s3, s4]. Temos

m1(x) = 1 + x + x4

m3(x) = 1 + x + x2 + x3 + x4

e portanto podemos computar os componentes da síndrome como

s1 = r(�) = ��1(�) = �

s2 = r(�2) = ��2(�) = ��1(�2) = �2

s3 = r(�3) = ��3(�) = 0

s4 = r(�4) = ��4(�) = ��1(�4) = �4

ou S = [�,�2,0, �4].

Cada componente da síndrome, sk , corresponde, portanto, ao cômputo do polinômio (vetor)

de erro e(x) em x = �k, sendo representado por um elemento de GF(2m). Se � erros ocorreram,

� t, nas posições j1, j2, ... , j�, podemos também escrever

Eq.8.23 e(x) = x j�

�

�

�

�1

, 0 j� (n-1)

Eq.8.24 sk = � � � � � ��

�

�

�

�

�

�

�

�k j j k k

� � �

� � ��

1 1 1, 1 k 2v

onde � ��

��j , 1 � �, são os denominados “números localizadores dos erros”. As

Eq.8.24, computadas para cada valor de k, nos dão um conjunto de equações relacionando os

coeficientes da síndrome aos números localizadores de erro ��, ou, especificamente,

s1 = ��

�1

v, s2 = � ��

�

2

1��v

, . . . s2v = � ��

2

1

vv

�

�

8.5.2 Determinação da Posição dos Erros

Podemos construir um polinômio, denominado “polinômio localizador dos erros”, na forma

Eq.8.25 ��(x) = �0 + �1x + �2x2 + ... + ��x�

= (1 + �1x)(1 + �2x) ... (1 + ��x)


ENE - UnB



8.14

cujas raízes são os inversos multiplicativos, em GF(2m), dos números localizadores dos erros.

Da Eq.8.25 podemos determinar que os coeficientes de ��(x) podem ser dados por

�0 = 1;

�1 = ��

�1

v;

�2 = � ��

�

�

�

�

� 11

1v;

. . .

�v = �1�2... �v.

O processo de decodificação de um código BCH envolve então os seguintes passos:

i. computar a síndrome s(x) a partir do vetor recebido r(x);

ii. construir o polinômio localizador dos erros ��(x) a partir de s(x);

iii. determinar as raízes de ��(x), determinando portanto os números localizadores dos erros ��;

iv. corrigir os erros em r(x) nas posições indicadas.

8.5.3 Decodificação pelo Método da Solução Direta

Deve-se a Peterson1 este algoritmo para a decodificação de códigos BCH binários, o qual foi

estendido por Gorenstein e Zierler2 para os casos não-binários, pelo qual o método ficou

também conhecido como método de Peterson, Gorenstein e Zierler.

Seja e(x) = e0 + e1x + e2x2 + ... + en-1xn-1 o polinômio erro onde � coeficientes são não-nulos,

� t. Sendo as posições dos erros dadas por j�, 1 � �, então

Eq.8.26 e(x) = e x e x e xjj

jj

jj

11

22

� � ��

�

�

Para códigos binários, temos sempre e j� = 1, ��. Para os casos não-binários, como para

códigos Reed-Solomon, que serão vistos adiante, precisamos também determinar a magnitude

dos erros em cada posição.

A síndrome, como visto, pode ser computada a partir do polinômio recebido. A partir da

Eq.8.24, podemos estabelecer

1 Error Correcting Codes, Peterson, W.W e Weldon Jr., E.J., MIT Press, Cambridge - Massachussets, 1972. 2 Xxxxx,



ENE - UnB



8.15

Eq.8.27 sk = y1�1k + y2�2

k + . . . + yv�vk, 1 k 2�

onde y� = e j� é a magnitude do erro na posição j�. Temos portanto um conjunto de 2�

equações simultâneas, para as quais devemos achar uma solução única. Tomando-se agora o

polinômio localizador dos erros, como expresso pela Eq.8.27, e multiplicando-se ambos os

lados daquela expressão por (y��k+�) e fazendo-se x = ��

-1, obtemos

��(��-1) = 0 = y1(��

k+� + �1��k+�-1 + �2��

k+�-2 + . . . + ��k)

que, fazendo-se o somatório em �, para cada k, obtemos

Eq.8.28 y y yk k k� �

�

�

�

� ��

�

�

� � �

�

�

� � � � ��

�

� �

� �

� � ��

11

1

1 10� .

Comparando-se a Eq.8.28 com com a Eq.8.27, observamos que cada um dos somatórios na

primeira corresponde a uma das componentes da síndrome, o que nos permite reescrevê-la

como

Eq.8.29 sk+� + �1sk+�-1 + �2sk+�-2 + ... + ��sk = 0, ou

��sk + ��-1sk+1 + ��-2sk+2 + ... + �1sk+�-1 = - sk+�

que nos fornece um conjunto de equações, para v t e 1 k �, que pode ser expresso, em

forma matricial, como

s s ss s s

s s s

1 2

2 3 1

1 2

1

1

1

2

2

�

�

� � � �

�

� �

�

�

�

�

�

�

�

�

�

�

�

�

�

�

�

�

�

�

��

�

�

��

�

�

��

�

�

��

�

�

�

��

�

�

��

v v

ss

s

,

ou

Eq.8.30

�

�

�

�

�

�

�

�

� �

�

�

�

�

��

�

�

��

�

�

�

��

�

�

��

1

1

1

1

2

2

� �M

ss

s

, com

Eq.8.31 M =

s s ss s s

s s s

1 2

2 3 1

1 2

�

�

� � � �

�

�

�

� � �

�

�

�

�

��

�

�

��

Podemos portanto determinar os coeficientes do polinômio localizador dos erros, ��(x),

construindo a matriz M, invertendo-a (caso seja não-singular), e aplicando o resultado na


ENE - UnB



8.16

Eq.32. O passo inicial é determinarmos o valor de �, o número de erros, desconhecido a

princípio, porém essencial para construirmos M e assim podermos determinar ��(x). Para

determinar �, supomos inicialmente que � = t. Se |M| � 0, então M é inversível, e � = t é o

verdadeiro valor para �. Se |M| = 0, então M é não-inversível, e � < t. Tentamos então � = t-1,

t-2, e assim sucessivamente, até que |M| � 0, quando então teremos o valor real de �. Note-se

que este processo sempre nos levará a um valor verdadeiro de �, ou seja, que nos permite

determinar uma solução para a Eq.8.30. Observe-se contudo que, caso tenham ocorridos erros

em número maior que a capacidade de correção do código, ou seja, se na realidade � > t, o

código poderá corrigir erroneamente o vetor recebido, por estar este mais próximo de alguma

outra palavra-código que da original.

Após a determinação dos coeficientes �i de ��(x), computa-se então suas raízes, determinando

as posições dos erros, o que, por sua vez, nos permite corrigir o vetor recebido, se for o caso.

Exemplo 4: Considere mais uma vez um código BCH (15,7,2), como analisado nos exemplos anteriores. Considere também,

mais uma vez, que a palavra-código é v(x) = 0 e a palavra recebida foi r(x) = e(x) = x6+x11.

Computando-se a síndrome, determinamos no exemplo 3 que temos S = [ �, �2, 0, �4 ]. Para determinarmos

��(x), façamos � = t = 2. Então

M = � �

�

0

22

�

��

�

�� e |M| = �2. �2 = �4 � 0

de modo que podemos computar

M-1 = 0

�

� �

1313 12

�

��

�

��

e assim,

��

�

� � ��

21

1 34 4

20��

��

��

��

��

�

��

��

�

��

�

��

�

��

�M ss

0

1313 12

correspondendo a

��(x) = �2x2 + �x + 1

cujas raízes são �2-1 = �4 e �1

-1 = �9, cujos inversos nos fornecem as posições dos erros como �2 = �11 e �1 =

�6, indicando um polinômio de erro e(x) = x6 + x11, como efetivamente ocorrido.



ENE - UnB



8.17

Exemplo 5: Consideremos o caso idêntico ao exemplo anterior, porém com a ocorrência de um único erro, de tal forma que

tenhamos r(x) = e(x) = x11. Agora temos

s1 = r(�) = �11

s2 = r(�2) = �7

s3 = r(�3) = �3

s4 = r(�4) = �14

S = [�11, �7, �3, �14]

supondo � = t = 2,

M = � �

� �

11 77 3

�

��

�

�� e |M| = �11. �3 + �7. �7 = �14 + �14 = 0,

e portanto � < 2. Fazendo � = 1 obtemos, M = [�11], |M| = �11 � 0, e portanto temos M-1 = [�4],

correspondendo a ��(x) = 1 + �11x, cuja raiz é �1-1 = �4, o que nos fornece �1 = �11, resultando em um

polinômio erro e(x) = x11, como realmente ocorrido.

8.6 Implementação de um Código BCH Corretor de 1-erro (Reinterpretando o Código de Hamming como Código Polinomial)

Vamos procurar interpretar o código de hamming, visto anteriormente, como um código

BCH. Como vimos, a matriz de checagem de paridade H pode ser construída atribuindo-se arbitra-

riamente as codificações para suas colunas, desde que distintas e não-nulas. Considere a utilização

dos elementos não-nulos de GF(2m) como os índices localizadores do erro, tomando-se m = r, o

número de dígitos de paridade. Estes elementos podem ser representados como potências de um

elemento �, raiz de algum polinômio primitivo de grau m, em GF(2), ou então como polinômios

binários de grau menor que m, em termos do mesmo elemento �. Vimos isto no capítulo 5.

Como exemplo, considere m = 3, como anteriormente, e seja o polinômio primitivo em

GF(2) dado por g(x) = x3 + x + 1. O código de hamming original tinha matriz de paridade na forma

que podemos agora interpretar como


ENE - UnB



8.18

e as posições dos erros, �i, são agora vistas como elementos de GF(8=23). O vetor recebido R =

[r0,r1,r2, ... ,r6], digamos, tem síndrome ST = HRT, e que pode ser vista como a soma, em GF(q),

das correspondentes posições dos erros:

Eq. 8.32 S �

�

�

� ri ii

n�

0

1, sobre GF(q)

onde, no nosso exemplo, o somatório é realizado para 0 i 6.

Desde que todas as possíveis n posições de erro tenham atribuídas em H valores distintos,

não-nulos, de GF(2m), o código será capaz de corrigir qualquer erro simples, como anteriormente.

Podemos portanto reordenar a matriz H tal que tenhamos �i = �i. Obtemos portanto

� � � � � � �

� � � �

� � � �

0 1 2 3 4 5 6

2 2 2 20 0 00 0 01 0 1 0 1 0 1

H �

�

�

��

�

�

��

ou utilizando coeficientes binários,

Esta atribuição torna-se atrativa quando vemos que, agora, a síndrome pode ser expressa

como um polinômio em �, explicitamente

Eq. 8.33 HR ( )T� �

�

�

� r Rii

i

n� �

0

1

onde associamos o polinômio R(x) ao vetor recebido R. Com esta notação polinomial, podemos

agora computar a síndrome de uma forma bastante interessante. Podemos escrever

Eq. 8.34 R(x) = q(x) g(x) + r(x),

onde r(x) tem grau menor que g(x), na forma usual de expressarmos uma divisão de polinômios. Se

escolhemos g(x) como o polinômio mínimo para �, então ele tem grau m, e g(�) = 0. Desta forma,

podemos escrever



ENE - UnB



8.19

Eq. 8.35 R(�) = r(�).

Vemos portanto que, dividindo-se R(x) por g(x), obtemos a síndrome como o valor do resto

da divisão, r(x), computado em x = �. Agora,

considerando nosso exemplo em que temos R(x)

um polinômio de grau 6 e o polinômio gerador

dado por g(x) = x3+x+1, como visto no capítulo 6,

o esquema ilustrado na figura 8.2 nos permite

dividir R(x) por g(x), e simultaneamente armaze-

narmos R(x) em um “buffer” temporário.

A correção de um eventual erro pode ser realizada de forma relativamente simples. Após

recebermos os n-bits de R(x), n = 8 neste exemplo, R(x) está armazenado no buffer superior, e o

resto da divisão por g(x) aparece no registro do divisor. Este RDRL é conhecido como RDRL

localizador do erro, visto que a síndrome pode ser dada por S = r(�). Se tiver ocorrido apenas um

erro, S nos fornece a posição deste erro no bloco

correspondente a R(x). Podemos agora empregar

um segundo RDRL, denominado RDRL corretor

do erro, na realidade um contador em GF(q), para

efetuarmos a correção do bit apontado como em

erro por S, conforme ilustrado no esquema da

figura 8.3. Supondo-se que S = �j, devemos

permitir que (n-1-j) bits de R(x) deixem o buffer,

invertendo (corrigindo) então o j-ésimo bit a

deixar o buffer. Consideraremos aqui j = -i, ou

seja, i = n-j, ou i = 7-j para nosso exemplo.

Transferimos o conteúdo de r(x) para o RDRL corretor do erro e damos um shift. O RDRL

localizador do erro é então reinicializado, pelo carregamento de zeros. O RDRL corretor do erro

contém agora �S. À medida em que os bits de R(x) deixam o buffer, correspondendo às posições

�14 = �-1, �13 = �-2, �-3, ... , �, 1, o corretor do erro contém, respectivamente, �S, �2S, �3S, ... , �14S

= �-1S, S. Assim, quando �-i deixa o buffer, �i S está no RDRL localizador do erro. Se a síndrome

foi S = �-i, então quando o dígito errado estiver deixando o buffer o localizador conterá �i�

-i = 1, o

que pode ser detetado pela lógica indicada (porta Não-OU), e a saída desta, ‘1’ neste instante, é

figura 8.2: Obtenção da Síndrome por divisão

polinomial.

figura 8.3: Um esquema de Correção em Código

Polinomial Corretor de 1-erro em GF(2).


ENE - UnB



8.20

adicionada ao dígito que está saindo do buffer, corrigindo o bit errado. Para todos os outros bits, a

saída da porta é ‘0’, e os bits saem do buffer sem alteração. Simultaneamente, enquanto se processa

a correção, um novo vetor recebido pode estar sendo processado, sendo colocado no buffer e tendo

o resto da divisão por g(x) computado no RDRL localizador, de modo que o processo pode ocorrer

de uma forma contínua, sem interrupções entre vetores.

Vamos agora considerar que a palavra código também será representada como um polinô-

mio,

Eq. 8.36 V x v xii

i

n( ) �

�

�

�0

1.

Agora, dados os (n-m) dígitos de informação, o codificador pode transmití-los como vn-1,

vn-2, ... ,vn-m, e os últimos m dígitos, vm-1,vm-2, ... ,v0, devem ser escolhidos de modo a que a

palavra-código completa V satisfaça a checagem de paridade. Com as posições na palavra-código

identificadas com as potências sucessivas de �, os requisitos das equações de paridade a que a

palavra código deve satisfazer são equivalentes a dizermos que V(�) = 0. Isto corresponde a termos

V(x) como um múltiplo do polinômio mínimo de �, g(x), neste caso o polinômio gerador do

código. Desta forma devemos poder escrever

Eq. 8.37 V(x) = q(x)g(x).

Considerando-se os (n-m) bits de informação como compondo um polinômio V’(x) dado por

Eq. 8.38 V’(x) = v xii

i m

n

�

�

�1

,

então, dividindo V’(x) por g(x) obtemos

Eq. 8.39 V’(x) = q’(x)g(x) + r(x),

onde r(x) tem grau menor que m. Temos portanto que V’(x) + r(x) = q’(x)g(x), sendo portanto

divisível por g(x). Assim, fazemos

Eq. 8.40 V(x) = V’(x) + r(x),

e temos V(x), múltiplo de g(x), a palavra código desejada. Para a codificação, portanto, basta

dividirmos V’(x) por g(x), tomarmos o resto da divisão e adicionarmos a V’(x) para obtermos a

palavra-código correspondente.



ENE - UnB



8.21

Este esquema para a codificação pode ser mecanizado pelo circuito da figura 8.4, onde é

utilizado um esquema ligeiramente modificado

para realizarmos a divisão polinomial. Inicial-

mente o RDRL está “zerado”, e todas as chaves

estão na posição superior. Os dígitos da mensa-

gem vn-1, vn-2, ... , vm, são passados diretamente

para o canal, à medida em que também entram no

RDRL divisor por g(x). Após estes n-m pulsos de relógio as chaves são mudadas para as posições

inferiores e aplicamos m zeros ao RDRL, enquanto o conteúdo do RDRL (os dígitos vm-1,vm-2, ... ,

v1, v0) é encaminhado para o canal, completando a palavra-código V(x), imediatamente após V’(x)

ter sido enviado. Agora as chaves podem ser retornadas à posição superior e o codificador se

encontra pronto para codificar o próximo vetor. Observe que V’(x), embora sendo um polinômio de

grau n, tem apenas n-m coeficientes. Se utilizássemos um divisor convencional, teríamos que

aguardar n pulsos de relógio para obtermos o resto da divisão por g(x), o que levaria a um hiato de

m bits entre a geração dos bits de informação e os bits de paridade estarem disponíveis.

8.7 Códigos Reed-Solomon (RS)

Um código RS3 é um código cíclico, corretor de símbolos, ou seja, opera diretamente sobre o

corpo extensão GF(qm), ao invés de GF(q), como o código BCH, e pode ser visto como um caso

particular dos códigos BCH, fazendo-se m = 1. Como um código cíclico, o código RS também tem

as características de um código linear. A disponibilidade de algoritmos de decodificação eficientes e

as características próprias do código tornam ele atrativo para diversas aplicações, em particular onde

se requeira proteção contra erros em surto (“rajadas de erros”).

Um código RS é formado por um bloco de símbolos sobre o Corpo Finito GF(qm). Em

particular estamos interessados em códigos sobre GF(2m), onde cada símbolo pode ser representado

por m-bits. A construção do código é semelhante àquela utilizada para qualquer código polinomial.

Os parâmetros de um código RS (n,k,t) sobre GF(2m) são:

�� n = (2m - 1) - comprimento do código, em símbolos de GF(2m);

�� t - capacidade de correção de erros aleatórios;

3 Polynomial Codes over Certain Finite Fields, Reed,I.S. e Solomon, G., J. Soc. Industr. Appl. Math., 8, pp 300-304, 1960.

figura 8.4: Codificação Polinomial.


ENE - UnB



8.22

�� k = (n - 2t) - número de símbolos de informação;

�� r = 2t - número de símbolos de redundância;

�� d0 = (2t + 1)- distância mínima do código.

Sendo g(x) o polinômio gerador do código e d(x) = d0 + d1x + d2x2 + ... + dk-1xk-1 o

polinômio informação, obtemos o polinômio-código na forma usual para um código polinomial

como

v(x) = v0 + v1x + v2x2 + ... + vn-1xn-1

= xn-kd(x) - p(x)

e, como em GF(2m) temos que � = -�, �� GF(2m), podemos também escrever

v(x) = xn-kd(x) + p(x),

onde

xn-kd(x) = q(x)g(x) + p(x),

como visto anteriormente.

Podemos então visualizar a palavra-código como um vetor-código, na forma

V = [p0, p1, p2, ... , pn-k-1,d0, d1, d2, ... , dk-1]

onde os dígitos pi, 0 i n-k-1, são os dígitos de redundância, e os dígitos d j, 0 j k-1, são os

dígitos de informação.

O polinômio gerador para um código RS (n,k,t) é definido como

g(x) = ( )x xi� �

�

�

�

�

�

� ��l i

i

t

ii

t

g0

2 1

0

2 1

Eq.41

onde � é um elemento primitivo de GF(2m) e l é um inteiro não-negativo. Em sua forma padrão

fazemos l = 1, obtendo

g(x) = (x - �)(x - �2) ... (x - �2t). Eq.42

Para certas implementações, em particular para implementações em hardware, pode ser

vantajoso o uso de um valor diferente para l, que resulte em economia de componentes. Em

particular, sendo a distância mínima do código, d0, um número ímpar, como em nosso caso, se

escolhermos

ln t k

�

� �

�

�2 12

12

Eq.43

obteremos um polinômio gerador simétrico, ou seja, os coeficientes dos termos de ordens



ENE - UnB



8.23

complementares são idênticos: g0 = g2t; g1 = g2t-1; etc., o que irá requerer o processamento de

apenas cerca de metade dos coeficientes do polinômio.

Exemplo 6: Seja um código RS (15,11,2). Temos então

n = 15 símbolos por palavra-código;

k = 11 símbolos de informação;

t = 2 símbolos em erro, no máximo;

m = 4 Corpo Finito GF(24) = GF(16).

Considerando GF(16) gerado pelo polinômio x4+x+1, primitivo em GF(2), conforme o Anexo I, o polinômio

gerador do código, em sua forma padrão, será dado por

g(x) = (x+�)(x+�2)(x+�3)(x+�4)

�10 + �3x + �6x2 + �13x3 + x4.

Tomando-se d(x) = �3 + �11x7 + �4x8 + �9x10, então

d’(x) = x4d(x)

= �3x4 + �11x11 + �4x12 + �9x14

= q(x)g(x) + p(x)

� p(x) = �13 + �2x + �5x2 + �11x3,

e c(x) = �13 + �2x + �5x2 + �11x3 + �3x4 + �11x11 + �4x12 + �9x14

ou C = [�13, �2, �5, �11, �3, 0, 0, 0, 0, 0, �11, �4, 0, �9]

que, codificando-se os elementos de GF(16) em quádruplas de GF(2), corresponde a

D = [0001 0000 0000 0000 0000 0000 0000 0111 0011 0000 0101]

C = [1011 0010 1100 0111 0001 0000 0000 0000 0000 0000 0000 0111 1100 0000 0101]

Exemplo 7: Agora, se optarmos pelo polinômio gerador simétrico, teremos

lk

�

�

�

12

6

g(x) = (x+�6) (x+�7) (x+�8) (x+�9)

= 1 + �3x + �x2 + �3x3 + x4.

Então, para o mesmo vetor-informação que do exemplo anterior, passamos a ter

d’(x) = q(x)g(x) + p(x),


ENE - UnB



8.24

com p(x) = �12 + �11x + �8x2 + �3x3,

e portanto

c(x) = �12 + �11x + �8x2 + �3x3 + �3x4 + �11x11 + �4x12 + �9x14,

ou, em notação vetorial,

C = [1111 0111 1010 0001 0001 0000 0000 0000 0000 0000 0000 0111 1100 0000 0101]

O processo de decodificação de um código RS é em tudo semelhante ao de outros códigos

polinomiais, e, em particular, podemos adotar os procedimentos vistos para a decodificação de um

código BCH. A diferença está em que, aqui, além da posição dos erros, precisaremos também

computar a magnitude dos mesmos.

Para a determinação da magnitude dos erros, nos utilizaremos de um polinômio avaliador

dos erros, ��(x), obtido como o produto de ��(x), o polinômio localizador, e s(x), a síndrome,

tomando-se apenas os termos até ordem v, o número de erros ocorridos, ou seja,

��(x) = ��(x)s(x)|v = 1 + (s1+�1)x + (s2+�1s1+�2)x2 + ... + (sv+�1sv-1+ ... +�v)xv Eq.44

Por conveniência, podemos considerar a síndrome como um polinômio infinto,

s(x) = s xkk

k�

�

�0

Eq.45

que, junto com a Eq.26, pode ser reescrito como

s(x) = � �e xe

x

kj

vj k

k

jj

v

�

� �

��

��

�

�

� � ��1 0 11

Eq.46

A eq.39 acima nos permite reescrever o polinômio avaliador do erro como

��(x) = e xj

vj

kk

v

�

�

�

�

�

� �

�

� � �

1 11( ) Eq.47

e portanto o valor (magnitude) do erro na posição x = e� j� pode ser obtido como

e j

j

j j

kk

vk

�

�

�

� �

� �

�

�

�

�

�

�

�

�

( )

( )11

. Eq.48

Exemplo 8: Considere o código RS (15,11,2) construído no exemplo 6. Suponha que ocorreram dois erros, sendo e(x) dado

por e(x) = �3x7 + �12x11. Agora, o vetor recebido será



ENE - UnB



8.25

r(x) = c(x) + e(x)

= �13 + �2x + �5x2 + �11x3 + �3x4 + �3x7 + x11 + �4x12 + �9x14.

Fazendo-se v = 2, os coeficientes da síndrome podem ser calculados como

s1 = r(�) = �

s2 = r(�2) = �10

s3 = r(�3) = �7

s4 = r(�4) = �6

de modo que

M = � �

� �

10

10 7�

��

�

��

� |M| = �4 � 0 � M-1 = � �

� �

3 6

6 12�

��

�

�

e então temos

�

�

� �

� �

�

�

�

�

2

1

1 3

4

3 6

6 12

3

7

3

8�

��

�

��

�

��

�

��

�

��

�

��

�

��

�

��

��

�

��

�Mss

e assim o polinômio localizador é dado por

��(x) = 1 + �8x + �3x2.

Determinando-se as raízes de ��(x) obtemos �4 e �8, que representam os inversos das posições dos erros, ou

seja

� �

� �

�

�

�

��

�

�

��

��

��

j

jjj

1

2

8

41

2

711

,

como esperado.

Agora precisamos determinar a magnitude dos erros, através o polinômio avaliador ��(x), que pode ser obtido

como

��(x) = 1 + (�+�8)x + (�10+�.�8+�3)x2

= 1 + �10x + �8x2.

Utilizando a eq.41, podemos então determinar

e j

j

j j1

1

2 11 11

1

8

11 8

18 24

19

43

�

�

�

�

�

� �

�

� �

�

�

� �

� �

� �

� �

� �

�

�

�

�

( )( )

( )( )

e j

j

j j2

2

1 21 11

1

4

7 4

14 16

1

9

1212

�

�

�

�

�

� �

�

� �

�

�

� �

� �

� �

� �

� �

�

�

�

�

( )( )

( )( )

e portanto, o polinômio-erro deve ter sido e(x) = �3x7 + �12x11, que, somado (subtraído) a r(x) recupera c(x), o

polinômio transmitido.


ENE - UnB



8.26

Uma característica verificada nos códigos RS é que, como um código não-ótimo, ou seja,

possui mais redundância que o estritamente necessário para detetar as combinações de erro para o

qual foi projetado, é possível se detetar situações em que a quantidade de erros excede a capacidade

de correção do código, embora não seja possível corrigí-los.

8.8 Códigos Corretores de Erros em Salva (“Burst”)

A necessidade de construção de códigos corretores de erro com capacidades corretivas cada

vez maiores conduzem naturalmente o problema da situação de correção de erros independentes ao

problema de correção de erros em salva.

Já vimos que os códigos corretores de t-erros têm baixas taxas à medida que t aumenta, se

tornando portanto ineficientes. Isto ocorre porque estes códigos são construídos para corrigir todas

as combinações de t erros ou menos em um dado bloco. Claramente, a estas taxas de erro por pala-

vra (bloco), torna-se mais realista considerarmos que os t-erros mais provavelmente ocorrerão agru-

pados em salvas, ao invés de espalhados por toda a palavra código. Este argumento advém do fato

de que, frequentemente, meios de comunicação sujeitos a este tipo de erro podem operar durante

períodos relativamente longos sem ocorrência de erros, e então estarem sujeitos a salvas concen-

tradas de erros (e.g. devido a descargas atmosféricas, defeitos em meios magnéticos, etc.). Tipica-

memte podemos passar centenas ou milhares de dígitos sem interferência, e de repente perdermos

algumas dezenas de dígitos. Estes fatos nos levam à investigação da possibilidade de construirmos

códigos especificamente para a correção destes erros-em-salva. A proteção contra este tipo de erro

utilizando um código normal, para correção de até t-erros, claramente exigiria altíssima redun-

dância, e portanto baixa taxa, e contudo esta proteção efetivamente não seria necessária a maior

parte do tempo. Os códigos para correção de erros-em-salva que veremos a seguir têm palavras

códigos compridas e capacidade para correção de uma única salva de erros arbitrariamente longa,

que ocorra dentro de um único bloco. A idéia principal é melhorar a capacidade de correção do

código pela limitação à condição de ocorrência de salvas de até b erros, ao invés de capacidade de

correção de qualquer combinação de até b erros, dentro de uma palavra. Na prática, o que se está

considerando é que algumas combinações de até b erros são mais prováveis que outras.

Uma salva de comprimento b é definida como uma sequência de b dígitos de erro, onde o

primeiro e o último são obrigatoriamento não-nulos. por exemplo, sobre GF(2) poderíamos ter:



ENE - UnB



8.27

transmite 11011000101110100110100011 recebe 11011110000110100110100011 erros 00000110101000000000000000

salva de comprimento 6

As possíveis salvas de comprimento 6 são 100001 101001 110001 111001 100011 101011 110011 111011 100101 101101 110101 111101 100111 101111 110111 111111

e existem, em geral, 2b-2 possíveis salvas de comprimento b.

Pode-se mostrar que, para se poder corrigir todas as possíveis salvas de comprimento b ou

menor, um código linear deve ter pelo menos 2b símbolos de paridade (bits de paridade no caso de

GF(2)). Além disso, se g(x) é o polinômio gerador de um código cíclico (n,k) capaz de corrigir

salvas de até b-erros, então g(xs) gera um código cíclico (ns,ks) capaz de corrigir salvas de compri-

mento s·b. Esta técnica de obter-se um código (ns,ks) a partir de um código (n,k) é conhecida como

entrelaçamento de símbolos.


ENE - UnB



8.28

8.9 Problemas Propostos

1. (a) Caracterize a natureza cíclica dos códigos polinomiais; (b) Determine o dicionário para o

código BCH (15,5,3), utilizando a estrutura de GF(24) obtida a partir de x4+x3+1, primitivo

sobre GF(2); (c) Mostre as relações cíclicas existentes no dicionário obtido em (b).

2. (a) Descreva os passos envolvidos na codificação e decodificação de um código BCH corretor

de erros múltiplos; Mostre que um código RS é um caso particular do código BCH.

3. (a) Defina a forma geral para o polinômio gerador de um código BCH (n,k,t) sobre GF(q). (b)

Sendo n = 63, determine os valores dos parâmetros k e t possíveis para a construção de um

código BCH primitivo sobre GF(2), GF(4) e GF(8).

4. Um código BCH binário de palavra código de comprimento 15 foi utilizado para a transmissão

de inteiros decimais na faixa de 0 a 127, na forma binária. Suponha que a palavra

010111100101001 é recebida (dígito mais significativo à direita), e, sendo o polinômio

gerador dado por g(x) = 1+x+x2+x4+x8, verifique que ocorreu um erro simples, localize e

corrija o erro, identificando, assim, o número transmitido.

5. Suponha que se deseja estabelecer um sistema corretor de erros em salva capaz de corrigir

qualquer salva binária de comprimento máximo de 16 bits. Considerando-se além da

capacidade de correção o problema da eficiência do código, que código você sugere para

resolver este problema? Justifique sua resposta.

6. Determine um polinômio gerador para um código RS (31,25,3). Considerando-se que os dados

a serem transmitidos são, efetivamente em binário, qual a capacidade de correção de erros em

salva deste código?

7. Compare as características de um código BCH (15,7,2) binário, com as de um código RS

(15,7,2), construído sobre GF(16), para uso também em transmissões binárias.

8. Desenvolva um programa para o IBM-PC implentando o código de Hamming (15,11), como

um código linear, para a proteção de arquivos.

9. Desenvolva um programa para o IBM-PC implentando o código BCH (15,7,2), binário, para a

proteção de arquivos.

10. Desenvolva um programa para o IBM-PC implentando o código RS (15,7,2), para a proteção

de arquivos.

8. sistemas para deteção/correção de erros

Documents

Transcript of 8. sistemas para deteção/correção de erros