Appunti di Teoria dell'Informazione e Codici - tti.unipa.itgarbo/Teoria InfeCodici_2012_01_12.pdf · Capitolo - 1 - Appunti di Teoria dell’Informazione e Codici ∑ ( ) A (1.1.1)

Dipartimento di Ingegneria Elettrica, Elettronica e delle Telecomunicazioni Università di Palermo

Appunti di Teoria dell'Informazione

e Codici

Giovanni Garbo, Stefano Mangione 03/03/2011

ii Appunti di Teoria dell’Informazione e Codici

Sommario

.......................................................................................................... 7 Capitolo - 1

Le Sorgenti d’Informazione ............................................................................... 7

1.1 - Premessa .................................................................................................................. 7

1.2 - Misura dell’Informazione ...................................................................................... 8

1.3 - Sorgenti d’Informazione ...................................................................................... 10 Esempio I.1.1 ............................................................................................................................ 13

1.4 - Informazione Associata a un Messaggio ............................................................. 13

........................................................................................................ 15 Capitolo - 2

Sorgenti con Alfabeto Continuo ...................................................................... 15

2.1 - Entropia di una Sorgente con Alfabeto Continuo ............................................. 15

2.2 - Sorgenti Gaussiane ............................................................................................... 16

........................................................................................................ 19 Capitolo - 3

La Codifica di Sorgente .................................................................................... 19

3.1 - Premessa ................................................................................................................ 19

3.2 - La Regola del Prefisso .......................................................................................... 19

3.3 - Lunghezza Media di un Codice. .......................................................................... 20

3.4 - La Disuguaglianza di Kraft. ................................................................................ 21 Esempio 3.1 .............................................................................................................................. 21

3.5 - Limite Inferiore per la Lunghezza di un Codice. .............................................. 22 Esempio 3.2 .............................................................................................................................. 23

3.6 - La Proprietà di Equipartizione. .......................................................................... 24

3.7 - Teorema sulla Codifica di una Sorgente DMS. .................................................. 25 Teorema 3.1 .............................................................................................................................. 27 Esempio 3.3 .............................................................................................................................. 27

3.8 - Codifica di Sorgenti con Memoria. ..................................................................... 28 Esempio 3.4 .............................................................................................................................. 29 Esempio 3.5 .............................................................................................................................. 29

........................................................................................................ 31 Capitolo - 4

Canali Privi di Memoria ................................................................................... 31

4.1 - L’Informazione Mutua. ....................................................................................... 31

4.2 - Concetto di Canale. .............................................................................................. 32

4.3 - Il Canale Simmetrico Binario. ............................................................................. 34

4.4 - Capacità del Canale AWGN a Banda Limitata. ................................................ 35

4.5 - Informazione Mutua tra M-messaggi. ................................................................ 37

4.6 - Canali in Cascata. ................................................................................................. 38

ii Appunti di Teoria dell’Informazione e Codici

4.7 - L’Inverso del Teorema della Codifica di Canale ............................................... 40 Teorema 4.1 .............................................................................................................................. 43

........................................................................................................ 45 Capitolo - 5

Cenni di Trasmissione Numerica ..................................................................... 45

5.1 - Scenario di Riferimento. ...................................................................................... 45

5.2 - Struttura del modulatore e del codificatore di sorgente ................................... 45

5.3 - Struttura del Ricevitore. ...................................................................................... 46

5.4 - La Regola di Decisione Ottima. ........................................................................... 47

5.5 - Il Criterio della Massima Verosimiglianza. ....................................................... 47

5.6 - Funzioni di Verosimiglianza. ............................................................................... 48

5.7 - Le Regioni di Decisione. ....................................................................................... 48

5.8 - L’Union Bound. .................................................................................................... 50

5.9 - Bound di Bhattacharrya. ..................................................................................... 52

5.10 - Bound di Gallager. ............................................................................................. 55

........................................................................................................ 57 Capitolo - 6

Il Teorema di Shannon sulla Codifica di Canale ............................................ 57

6.1 - Premessa. ............................................................................................................... 57

6.2 - La Disuguaglianza di Jensen ............................................................................... 57 Definizione 6.1 .......................................................................................................................... 58 Definizione 6.2 .......................................................................................................................... 58

6.3 - Il Teorema di Shannon sulla Codifica di Canale. .............................................. 60 Teorema 6.1 .............................................................................................................................. 66

........................................................................................................ 69 Capitolo - 7

Strutture Algebriche .......................................................................................... 69

7.1 - Gruppo .................................................................................................................. 69

7.2 - Anello ..................................................................................................................... 69

7.3 - Campo ................................................................................................................... 69

7.4 - Spazio vettoriale ................................................................................................... 69

........................................................................................................ 71 Capitolo - 8

8.1 - Lo Spazio ........................................................................................................ 71

8.2 - Generalizzazione della distanza di Hamming .................................................... 72

........................................................................................................ 73 Capitolo - 9

Codici Binari a Blocchi..................................................................................... 73

9.1 - Codificatore, Codice, Decodificatore .................................................................. 73 Definizione 9.1 - codificatore a blocchi .................................................................................... 73 Definizione 9.2 - codice binario a blocchi ................................................................................ 73 Definizione 9.3 - decodificatore ................................................................................................ 74

9.2 - Utilità della codifica di canale ............................................................................. 74

9.3 - La decodifica a massima verosimiglianza .......................................................... 76 Regola di decisione a Massima Verosimiglianza ...................................................................... 76

Indice iii

9.4 - Definizioni e teoremi sui codici rivelatori e correttori ...................................... 77 Definizione 9.4 ......................................................................................................................... 77 Definizione 9.5 ......................................................................................................................... 77 Teorema 9.1 .............................................................................................................................. 78 Definizione 9.6 ......................................................................................................................... 78 Teorema 9.2 .............................................................................................................................. 78

...................................................................................................... 81 Capitolo - 10

Codici Lineari a Blocchi .................................................................................. 81

10.1 - Premessa .............................................................................................................. 81

10.2 - Morfismi .............................................................................................................. 81 Definizione 10.1 - omomorfismo.............................................................................................. 81 Definizione 10.2 - monomorfismo............................................................................................ 82 Definizione 10.3 - isomorfismo ................................................................................................ 82

10.3 - Schema di principio di un codice lineare a blocco ........................................... 82

10.4 - Matrice generatrice del codice .......................................................................... 83

10.5 - Distribuzione dei pesi di un codice lineare a blocco ........................................ 84 Definizione 10.4 ....................................................................................................................... 84

10.6 - Capacità di rivelazione di un codice lineare a blocco ...................................... 85 Teorema 10.1 ............................................................................................................................ 85

10.7 - Probabilità di non rivelazione d’errore di un codice lineare .......................... 85

10.8 - Laterali di un sottogruppo ................................................................................. 86

10.9 - Decodifica tramite i rappresentanti di laterale ................................................ 87 Teorema 10.2 ............................................................................................................................ 88

10.10 - Probabilità d’errore di un codice lineare a blocchi ....................................... 88

10.11 - Codici perfetti, bound di Hamming ................................................................ 89

...................................................................................................... 91 Capitolo - 11

Codici Sistematici ............................................................................................. 91

11.1 - Codici Sistematici ............................................................................................... 91

11.2 - Matrice di controllo di parità ............................................................................ 92

11.3 - Codici duali ......................................................................................................... 93

11.4 - Decodifica basata sulla sindrome ...................................................................... 93

...................................................................................................... 95 Capitolo - 12

Codici di Hamming e loro duali ....................................................................... 95

12.1 - Codici di Hamming ............................................................................................ 95 Esempio 12.1 ............................................................................................................................ 96

12.2 - Duali dei codici di Hamming ............................................................................. 96

12.3 - Codici ortogonali e transortogonali .................................................................. 97

...................................................................................................... 99 Capitolo - 13

Codici Convoluzionali ...................................................................................... 99

13.1 - Premessa .............................................................................................................. 99

13.2 - Struttura del codificatore ................................................................................... 99

iv Appunti di Teoria dell’Informazione e Codici

13.3 - Matrice generatrice e generatori. .................................................................... 100

13.4 - Diagramma di stato del codificatore. .............................................................. 101

13.5 - Codici catastrofici ............................................................................................. 103

13.6 - Trellis degli stati ............................................................................................... 103 Esempio 13.1 ........................................................................................................................... 105

.................................................................................................... 107 Capitolo - 14

L’Algoritmo di Viterbi ..................................................................................... 107

14.1 - Decodifica hard e soft di un codice convoluzionale. ...................................... 107

14.2 - L’algoritmo di Viterbi ...................................................................................... 109

14.3 - Efficienza dell’algoritmo di Viterbi ................................................................ 111

.................................................................................................... 113 Capitolo - 15

Prestazioni dei Codici Convoluzionali ........................................................... 113

15.1 - Funzione di trasferimento di un codificatore convoluzionale. ..................... 113

15.2 - Bound sulla probabilità di primo evento d’errore. ....................................... 116 Esempio 15.1 ........................................................................................................................... 118

15.3 - Bound sulla probabilità d’errore sul bit informativo. .................................. 120

.................................................................................................... 123 Capitolo - 16

Anelli di Polinomi ........................................................................................... 123

16.1 - Premessa ............................................................................................................ 123

16.2 - L’anello polinomi a coefficienti in ............................................................... 123

16.3 - Spazi di polinomi .............................................................................................. 124

.................................................................................................... 125 Capitolo - 17

Codici polinomiali ........................................................................................... 125

.................................................................................................... 127 Capitolo - 18

Ideali di un anello di polinomi ....................................................................... 127

18.1 - Premessa ............................................................................................................ 127

18.2 - Ideali di un anello con identità. ....................................................................... 127 Teorema 18.1 .......................................................................................................................... 128 Teorema 18.2 .......................................................................................................................... 129

.................................................................................................... 131 Capitolo - 19

Codici Ciclici ................................................................................................... 131

19.1 - Rappresentazione polinomiale di un codice ciclico. ...................................... 131 Definizione 19.1 ...................................................................................................................... 131

19.2 - L’anello ...................................................................................... 131 Teorema 19.1 .......................................................................................................................... 133

19.3 - Polinomio generatore di un codice ciclico ...................................................... 133

19.4 - Polinomio di parità di un codice ciclico .......................................................... 133 Esempio 19.1 ........................................................................................................................... 134

19.5 - Matrice generatrice di un codice ciclico ......................................................... 135

Indice v

19.6 - Codici ciclici Sistematici ................................................................................... 135 Esempio 19.2 .......................................................................................................................... 136

19.7 - Duale di un codice ciclico ................................................................................. 136

.................................................................................................... 139 Capitolo - 20

Campi finiti ..................................................................................................... 139

20.1 - Polinomi irriducibili e campi ad essi associati ............................................... 139 Definizione 20.1 ..................................................................................................................... 139 Teorema 20.1 .......................................................................................................................... 139

20.2 - Ordine degli elementi di un gruppo ................................................................ 140

20.3 - Ordine degli elementi di un campo finito ....................................................... 140

20.4 - Ordine di un campo finito ................................................................................ 141 Teorema 20.2 - Ordine di un campo finito ............................................................................. 141

20.5 - Elementi primitivi di un campo ....................................................................... 142

20.6 - Campi di polinomi ............................................................................................ 142 Esempio 20.1 .......................................................................................................................... 143

20.7 - Polinomi irriducibili primitivi ......................................................................... 143 Definizione 20.2 ..................................................................................................................... 144 Definizione 20.3 ..................................................................................................................... 144 Teorema 20.3 .......................................................................................................................... 144

20.8 - Alcune proprietà dei campi finiti .................................................................... 145 Esempio 20.2 .......................................................................................................................... 145

.................................................................................................... 149 Capitolo - 21

Codici BCH ..................................................................................................... 149

21.1 - Codici BCH ....................................................................................................... 149 Esempio 21.1 .......................................................................................................................... 150

.................................................................................................... 155 Capitolo - 22

La Trasformata di Fourier Discreta .............................................................. 155

22.1 - La Trasformata di Fourier Discreta ............................................................... 155

22.2 - DFT e codici ciclici ........................................................................................... 157 Definizione 22.1 ..................................................................................................................... 157

Capitolo - 1

LE SORGENTI D’INFORMAZIONE

1.1 - Premessa

Uno dei maggiori problemi che s’incontrano nella stesura di un testo che tratti la

teoria dell’informazione è quello della notazione da adottare, non è, infatti, semplice

trovare il giusto compromesso tra sinteticità e chiarezza della stessa.

Nel seguito avremo spesso a che fare con variabili aleatorie (V.A.) che indicheremo

con lettere maiuscole. Come è noto ad ogni V.A. si può associare una distribuzione di

probabilità (DDP) ed una densità di probabilità (ddp) che altro non è se non la

derivata della DDP, intesa eventualmente in senso generalizzato.

Nel caso delle variabili aleatorie discrete che possono cioè assumere un numero

finito di valori è più comodo fare riferimento alla distribuzione di massa di probabilità

(dmp) cioè ad una funzione ( ) che associa ad ogni valore che la V.A. può

assumere la probabilità dell’evento: “ assume il valore ”.

Quando si riterrà che non vi siano possibilità d’equivoci si ometterà il pedice che

individua la V.A. affidando all’argomento della funzione anche questo compito, cioè

( ) ( ).

Si noti che la notazione che qui si adotta è purtroppo analoga a quella

normalmente utilizzata per indicare la ddp di una variabile aleatoria, un minimo di

attenzione al contesto dovrebbe, si spera, essere sufficiente ad evitare confusioni. Le

ddp verranno di regola indicate con lettere greche con a pedice la V.A. cui si

riferiscono ad esempio ( ).

Come è noto per le variabili aleatorie discrete è particolarmente semplice desumere da

una qualunque delle tre funzioni di probabilità appena citate le altre. In particolare se è

nota la dmp di una variabile aleatoria discreta che assume valori appartenenti

all’insieme la corrispondente DDP ( ) sarà una funzione definita su

tutto costante a tratti con discontinuità d’ampiezza ( ) in corrispondenza dei

valori che la V.A. può assumere. La ddp ( ) sarà espressa da ( )

∑ ( ) ( )

.

Nel calcolo delle sommatorie che s’incontreranno ad ogni piè sospinto si

indicherà il più sinteticamente possibile l’indice su cui le suddette operano. Ad esempio

avendo a che fare con una V.A. discreta che assuma valori in un insieme

, la condizione di normalizzazione della sua dmp sarà indicata come segue:

8 Capitolo - 1 - Appunti di Teoria dell’Informazione e Codici

∑ ( )

A

(1.1.1)

anziché:

∑

( ) (1.1.2)

Analogamente quando si avrà a che fare con variabili aleatorie multidi-

mensionali, come ad esempio nel caso di una -upla di simboli emessi consecutiva-

mente, si utilizzeranno distribuzioni di massa congiunte che saranno caratterizzate

scrivendo, ove possibile, pedice e argomento in grassetto. Ad esempio nel caso di una

coppia di variabili aleatorie che assumono entrambe valori sull’insieme , la

condizione di normalizzazione verrà sinteticamente scritta:

∑ ( )

A

(1.1.3)

anziché

∑ ∑ ( )

(1.1.4)

Nel caso delle ddm condizionate con

( ) (1.1.5)

si indicherà sinteticamente la seguente probabilità condizionata:

( ) (1.1.6)

anche in questo caso, quando si riterrà che non vi siano possibilità d’equivoci si

ometterà il pedice affidando agli argomenti l’identificazione delle variabili aleatorie cui

si fa riferimento.

1.2 - Misura dell’Informazione

Il concetto d’informazione a livello intuitivo è chiaro. Si acquisisce un’infor-

mazione nel momento in cui si viene a conoscenza di qualcosa che prima ci era ignoto.

Quantificare l’informazione da un punto di vista matematico richiede invece qualche

riflessione.

Per inquadrare meglio il problema facciamo riferimento ad un esperimento

casuale che com’è noto è caratterizzato da un insieme di possibili risultati, da una

famiglia d’eventi (insiemi di risultati) e dalle probabilità associate a ciascuno di essi.

In prima istanza si accetta facilmente l’idea che il contenuto informativo di un evento

sia tanto più grande quanto più esso è inatteso, ciò ad esempio si riflette nella

dimensione del carattere utilizzato nei titoli di un quotidiano che, di regola, è

Le Sorgenti d’Informazione 9

direttamente proporzionale alla “sensazionalità” dell’evento di cui il titolo intende dare

notizia. Una notizia è tanto più sensazionale quanto più essa è inattesa, “un padrone ha

morso il suo cane”.

Pertanto, volendo definire una misura per la quantità d’informazione associata ad

un evento, minor prevedibilità deve equivalere ad un valore maggiore di tale misura.

Inoltre, qualora si verifichino più eventi, per semplicità prendiamone in con-

siderazione solo due, la misura dell’informazione complessiva dovrebbe essere pari alla

somma delle informazioni acquisite con il manifestarsi dei singoli eventi, sempre che le

informazioni acquisite con il manifestarsi di uno di essi non abbiano reso più

prevedibile se non addirittura certo, o anche impossibile, il manifestarsi del secondo.

In conclusione appare abbastanza chiaro che un’accettabile misura dell’informazione

debba essere:

- legata alla probabilità che il generico evento ha di manifestarsi ed in particolare

debba crescere al diminuire di essa e debba variare con continuità al variare di

quest’ultima;

- nel caso di un evento congiunto debba essere pari alla somma delle informazioni

associate ai singoli eventi, se questi sono tra loro statisticamente indipendenti.

Ricordando che la probabilità che si verifichino più eventi statisticamente in-

dipendenti è pari al prodotto delle probabilità dei singoli eventi, si può pensare di

quantificare l’informazione sfruttando la nota proprietà dei logaritmi

( ) ( ) ( ) (1.2.1)

In particolare si assume come informazione (A) associata ad un evento che si

manifesta con probabilità (A) valga:

(A) (

) (1.2.2)

È opportuno sottolineare che l’informazione associata all’evento non dipende

dalla natura di quest’ultimo, ma solo dalla probabilità che esso ha di manifestarsi,

pertanto la notazione utilizzata è in realtà impropria in quanto presenta l’informazione

come associata all’evento e non alla sua probabilità.

Si verifica facilmente che (1.2.2) soddisfa i due requisiti sopra indicati, in

particolare cresce al diminuire di . É stato anche dimostrato che il logaritmo è l’unica

funzione che soddisfa i requisiti sopra elencati.

Osserviamo anche che la base adottata per il logaritmo non è concettualmente

importante, cambiarla equivale infatti ad introdurre un fattore di scala, come appare

ovvio se si ricorda la regola per il cambiamento di base dei logaritmi:


(1.2.3)

In pratica scegliere la base nella (1.2.2) equivale a scegliere una particolare unità di

misura. La potenza di un motore non cambia se viene misurata in KW o in HP, anche

se espressa in cavalli è più accattivante.

Nella Teoria dell’Informazione si utilizzano tipicamente due basi per il logaritmo

che compare nella (1.2.2) la base se si intende misurare l’informazione il nat, o la

base se la si vuole misurarla in bit (binary information unit non binary digit).

Ad esempio nel caso del lancio di una moneta non truccata al manifestarsi dell’evento

è associata un’informazione pari a –

o a –

L’utilizzo del bit come unità di misura è di regola preferito dal momento che la

quasi totalità dei moderni sistemi di informazione utilizza sistemi di calcolo che

lavorano in base 2 e che i dati tra computer vengono scambiati tipicamente sotto forma

di parole binarie. In quel che segue il logaritmo naturale verrà indicato con ed il

logaritmo in base con omettendo cioè l’indicazione della base.

1.3 - Sorgenti d’Informazione

Una sorgente d’informazione, è un sistema che emette in modo più o meno

casuale sequenze d’elementi appartenenti ad un assegnato insieme, l’alfabeto della

sorgente. Come vedremo, la natura dei simboli è del tutto inessenziale per lo sviluppo

della teoria, potremo quindi sempre pensare che l’alfabeto sia numerico, cioè che la

sorgente emetta una sequenza di variabili aleatorie, che, se l’insieme è finito, saranno di

tipo discreto. In alternativa possiamo sempre pensare di definire sull’insieme dei

simboli emessi, che costituisce in sostanza l’insieme dei risultati di un esperimento

casuale, una V.A. biettiva.

Un sistema di trasmissione ha il compito di recapitare dei dati in modo affidabile

da un emissario a un destinatario. Il grado d’affidabilità del sistema può essere

caratterizzato dal numero d’errori da cui è mediamente afflitto.

Si osservi che emissario e destinatario possono anche trovarsi nello stesso luogo ed

essere addirittura lo stesso soggetto, come ad esempio avviene nel caso della

memorizzazione di dati, che si auspica possano essere utili in futuro, su un supporto

fisico.

L’emissario in sostanza è una sorgente d’informazione che può generare segnali

a tempo continuo o discreto.


Le sorgenti di tipo discreto sono quelle che emettono dei simboli, o lettere, ap-

partenenti ad un assegnato insieme, al più numerabile, che chiameremo alfabeto di

sorgente.

Se la probabilità che in un dato istante la sorgente emetta una qualunque lettera

non dipende dai simboli emessi negli altri istanti si dice che la sorgente è priva di

memoria.

Una sorgente discreta priva di memoria (Discrete Memoryless Source) potrebbe

ad esempio essere quella che emette la sequenza dei risultati ottenuti lanciando

ripetutamente un dado, l’alfabeto utilizzato sarebbe in questo caso costituito da sei

simboli che si potrebbero etichettare con i primi sei numeri naturali.

Viceversa una sorgente discreta dotata di memoria potrebbe essere una sorgente che

trasmette un testo in lingua italiana. Esisterebbero pochi dubbi su quale sarà il simbolo

emesso successivamente alla sequenza “p r e c i p i t e v o l i s s i m e v o l m e n t”, o

sul fatto che dopo l’emissione della lettera q verrà emessa una u, a meno che i due

simboli precedenti non siano stati s o, fatti salvi, ovviamente, gli errori, sempre in

agguato malgrado e, talvolta, a causa dei correttori ortografici.

Come anticipato nella premessa, non si perde generalità se si assume che la

sorgente emetta una sequenza di variabili aleatorie che assumono valori

appartenenti ad un sottoinsieme di che si può porre in corrispondenza biunivoca con

l’insieme delle lettere che costituiscono l’alfabeto della sorgente che supporremo finito.

In sostanza quanto detto equivale ad associare un’etichetta numerica ad ogni lettera

dell’alfabeto della sorgente.

In quel che segue supporremo che la sia stazionaria cioè che la sua

statistica a qualunque ordine dipenda esclusivamente dalla posizione relativa degli

istanti di osservazione, non dall’origine dei tempi. L’ipotesi appena fatta implica, tra

l’altro, che l’alfabeto utilizzato non vari al variare dell’indice temporale Detta la

V.A. emessa dalla sorgente all’istante , ad ogni simbolo dell’alfabeto si può

associare una probabilità d’emissione:

( ) (1.3.1)

L’informazione che si acquisirebbe rilevando l’emissione della lettera senza

nulla sapere sulle lettere precedentemente emesse varrebbe quindi:

( ) ( ) (1.3.2)

assumendo ove necessario (

) , alla sorgente si può associare la sua entropia:


( ) ∑ ( )

( )

∑

(1.3.3)

L’entropia ( ) appena definita, è la media statistica dell’informazione

associata all’emissione dell’ -esimo simbolo. Essa rappresenta pertanto l’informazione

che mediamente si acquisisce per effetto dell’emissione di un simbolo da parte della

sorgente all’istante . Osserviamo che la stazionarietà della sequenza comporta che

( ) sia indipendente da , tale indice può quindi essere omesso.

Si noti che anche l’entropia dipende esclusivamente dalla distribuzione di probabilità

dei simboli emessi e non dalla loro natura.

L’entropia di una sorgente, è limitata superiormente. In particolare se l’alfabeto

ha cardinalità si ha:

∑

(1.3.4)

Per verificare la precedente disuguaglianza consideriamo due possibili dmp:

∑

∑

(1.3.5)

vale la seguente catena di disuguaglianze:

∑

∑

∑

∑

∑ (

)

(1.3.6)

La maggiorazione effettuata è corretta in

quanto nell’insieme di definizione di risulta

(vedi Fig.E 1.1). La precedente permette

di affermare che se sostituiamo la dmp ad argomento

del logaritmo con una diversa da quella utilizzata per

il calcolo della media otteniamo comunque una

maggiorazione dell’entropia.

In particolare se nella (1.3.6) si sceglie

si ottiene: Fig.E 1.1 - 𝑦 𝑥 , 𝑦 (𝑥).


∑

∑

∑

∑

(1.3.7)

da cui la (1.3.4).

Esempio I.1.1

Si consideri una sorgente che emette simboli

appartenenti ad un alfabeto binario costituito quindi

da due soli simboli ad esempio, , detta la

probabilità che venga emesso il simbolo

l’entropia della sorgente vale:

( ) ( )

( )

Si osservi che ( ) (vedi Fig.E 1.2) in accordo

con la (1.3.7) raggiunge il suo massimo per

.

In sostanza una sorgente fornisce me-

diamente tanta più informazione quanto meno prevedibile è il simbolo che essa

emetterà. Nel caso di una sorgente binaria la massima entropia è pari ad un bit e si

ottiene quando la sorgente emette dati equiprobabili.

La (1.3.7) mostra che il massimo contenuto informativo medio si ottiene da

sorgenti in cui ogni simbolo ha la stessa probabilità di essere emesso di qualsiasi altro

appartenente all’alfabeto.

1.4 - Informazione Associata a un Messaggio

Si può anche definire l’informazione derivante dall’emissione di una -upla di

simboli emessi consecutivamente dalla sorgente. In questo caso parleremo di M-

messaggio emesso dalla sorgente, che possiamo pensare come la realizzazione di una

V.A. M-dimensionale . Se l’alfabeto della sorgente ha cardinalità

allora esisteranno al più possibili messaggi. Indicando con

A , il generico M-messaggio e con ( ) la probabilità che sia emesso, l’informazione

ad esso associata è data da:

( )

( ) (1.4.1)

mediando sui possibili messaggi otteniamo l’entropia associata all’M-messaggio:

( ) ∑ ( )

( ) A

(1.4.2)

Se i simboli emessi dalla sorgente sono i.i.d. allora risulta:

Fig.E 1.2 - Entropia di una sorgente binaria in

funzione della dmp dei dati


( ) ∏ ( )

(1.4.3)

sostituendo la precedente nella (1.4.2):

( ) ∑ ( )

( ) A

∑ ( )

∏ ( )

A

∑ ( ) ∑

( )

A

∑ ∑ ( )

( ) A

∑∑ ( )

( )

( )

(1.4.4)

pertanto, se la sorgente è stazionaria e priva di memoria, l’entropia associata ad un

messaggio di lunghezza M è M volte l’entropia associata al singolo simbolo.

Assumiamo adesso:

( ) ∏ ( )

(1.4.5)

( ) soddisfa ovviamente le condizioni necessarie per essere una possibile dmp di una

V.A.multidimensionale. Seguendo la falsariga della (1.3.6) si può scrivere:

∑ ( )

A

( ) ∑ ( )

A

( ) ∑ ( )

A

( )

( )

∑ ( )

A

( ( )

( ) )

(1.4.6)

d’altro canto risulta:

∑ ( )

A

( ) ∑ ( )

A

∏ ( )

∑ ( )

A

∑

( )

∑ ∑ ( )

( ) ∑ ∑ ( )

( ) A

A

∑ ( )

( )

(1.4.7)

dove l’ultima uguaglianza vale solo nel caso in cui la i simboli emessi dalla sorgente

siano identicamente distribuiti, cioè nel caso in cui la sorgente sia stazionaria, pur non

essendo necessariamente priva di memoria.

Dalle (1.4.6) e (1.4.7) deduciamo che in generale per sorgenti stazionarie risulta

( ) ( ) (1.4.8)

cioè a parità di cardinalità dell’alfabeto e di lunghezza del messaggio la massima

informazione media è fornita da sorgenti prive di memoria che emettono simboli

equiprobabili.

Capitolo - 2

SORGENTI CON ALFABETO CONTINUO

2.1 - Entropia di una Sorgente con Alfabeto Continuo

Consideriamo adesso una sorgente che emette con cadenza regolare simboli

appartenenti ad un insieme non numerabile. Potremo quindi sempre pensare che la

sorgente emetta una sequenza di variabili aleatorie di tipo continuo. La sorgente

sarà quindi completamente caratterizzata da un processo aleatorio a tempo discreto

continuo in ampiezza, che è completamente caratterizzato qualora sia nota la sua

statistica a qualunque ordine.

Per definire l’entropia ( ) di una tale sorgente, cioè l’informazione che

mediamente acquisiremmo in seguito all’emissione di un singolo simbolo, senza nulla

sapere dei simboli emessi precedentemente da una tale sorgente, dovremo

necessariamente fare riferimento alla densità di probabilità ( ) della variabile

aleatoria che essa genera in un dato istante. Se supponiamo che la sorgente sia

stazionaria tale densità di probabilità sarà indipendente dall’istante di osservazione.

Basandoci su quanto detto per le sorgenti con alfabeto discreto, sorge spontaneo

definire tale entropia come segue:

( ) ∫ ( )

( )

(2.1.1)

assumendo che

. Tale definizione non gode di tutte le proprietà di cui godeva

l’entropia di una sorgente con alfabeto finito, essa ad esempio può assumere anche

valori negativi e può non essere limitata.

Anche per le sorgenti ad alfabeto continuo possiamo definire l’entropia associata

a più simboli emessi. Nel caso di due soli simboli si ha:

( ) ∫ ∫ ( )

( )

∫ ∫ ( )

( )

∫ ∫ ( )

( )

( ) ( )

( ) ( )

(2.1.2)

se X e Y sono statisticamente indipendenti dalla precedente si ottiene:

( ) ( ) ( ) (2.1.3)

Si può provare che in generale risulta:

( ) ( ) ( ) (2.1.4)

Capitolo - 2 - Appunti di Teoria dell’Informazione e Codici 16

2.2 - Sorgenti Gaussiane

Osserviamo che:

( ) ∫ ( ) ( ( ))

∫ ( )( ( ) ) ∫ ( ( ))

( )

∫ ( ( ))

(2.2.1)

ne segue che se ∫ ( ( ))

la ( ) è limitata inferiormente. Ciò avviene

certamente se la ( ) è limitata. La sommabilità di ( ) garantisce in questo caso

anche quella di ( ( )) . La ( ) è certamente limitata inferiormente anche quando la

( ) non si mantiene limitata, purchè in corrispondenza ai valori di in cui diverge lo

faccia più lentamente di

con

per . Consideriamo adesso una

generica ddp ( ) risulta:

∫ ( )

( )

∫ ( )

( ) ∫ ( )

( )

( )

∫ ( ) (

( )

( ) )

(2.2.2)

La precedente può essere pensata come una generalizzazione della (1.4.6).

Supponiamo che la sorgente emetta una variabile aleatoria con varianza finita ,

ponendo nella (2.2.2) ( )

√

( )

, cioè scegliendo una ddp Gaussiana con

varianza otteniamo:

∫ ( )

( )

∫ ( ) (√

( )

)

√ ∫ ( )

∫ ( ) (

( )

)

(

) ∫ ( )( )

(

)

(

)

(2.2.3)

d’altro canto si verifica facilmente che

(

) è anche l’entropia di una variabile

aleatoria Gaussiana, con varianza .

Quanto appena esposto ci porta a concludere che a parità di varianza le sorgenti

continue Gaussiane generano la massima informazione media.

Sorgenti con Alfabeto Continuo 17

È opportuno osservare che l’entropia di una sorgente stazionaria continua è

indipendente dal valor medio della variabile aleatoria emessa. Un valor medio non

nullo incide solo sul valor quadratico medio della sequenza emessa aumentandolo. Il

che in altri termine vale a dire che un valor medio diverso da zero aumenta la potenza

media del processo senza offrire alcun beneficio in termini d’informazione media a

esso associata.

Capitolo - 3

LA CODIFICA DI SORGENTE

3.1 - Premessa

Gli attuali sistemi di trasmissione sono spesso basati su un mezzo trasmissivo di

capacità limitata che viene condiviso tra più utenti, diventa quindi essenziale cercare di

ottimizzarne l’utilizzo al fine di consentire l’accesso alla risorsa ad un maggior numero

di soggetti. È quindi auspicabile mettere in atto dei metodi che consentano di

“compattare” le informazioni da trasmettere in modo da utilizzare il sistema per il

minor tempo possibile, ovvero da occupare una minore quantità di banda, senza

pregiudicare il contenuto informativo del messaggio. Lo stesso discorso ovviamente

vale nel caso dell’immagazzinamento delle informazioni, “zippare” un file serve a

sfruttare meglio la memoria dell’hard disk.

La quasi totalità dei sistemi di trasmissione oggigiorno è numerica, e fa uso di

sistemi d’elaborazione digitale che lavorano in base due, pertanto ci occuperemo di

analizzare delle tecniche di codifica di sorgente che associno alle singole lettere o a

interi messaggi emessi da quest’ultima delle parole binarie cioè delle stringhe di

lunghezza non necessariamente costante costituite utilizzando un alfabeto di due sole

lettere.

Una sorgente che utilizza un alfabeto di cardinalità può emettere al più M-

messaggi distinti, se a ciascuno di essi si associa una parola binaria si dice che si è

definito un codice.

3.2 - La Regola del Prefisso

Il codice citato nel precedente paragrafo può essere costruito utilizzando parole

binarie tutte con lo stesso numero di bit, nel qual caso la lunghezza minima di tali

parole non potrà essere inferiore a:

( ) (3.2.1)

dove indica il primo intero non minore.

Si possono anche utilizzare parole di codice di lunghezza variabile, in questo

caso, però, occorrerà prestare attenzione al fatto che se s’invia un file costituito da più

M-messaggi consecutivi i singoli messaggi dovranno essere decodificabili in modo

univoco, dovremo in altri termini essere certi del fatto che a coppie distinte di sequenze

finite di messaggi il codice non associ la stessa stringa binaria (da qui in poi con stringa

indicheremo una sequenza di lunghezza finita di parole di codice).


Tale requisito è certamente soddisfatto se nessuna delle parole del codice è

identica alla parte iniziale di un’altra parola di codice. In questo caso diciamo che il

codice soddisfa la regola del prefisso.

È opportuno sottolineare che la regola del prefisso è solo sufficiente, si po-

trebbero cioè individuare dei codici che pur non rispettandola, sono decodificabili in

modo univoco. Tali codici tuttavia ci obbligherebbero per effettuare la decodifica ad

attendere la ricezione se non dell’intera sequenza di M-messaggi certamente di più di

un messaggio. Viceversa, se il codice soddisfa la regola del prefisso la decodifica può

essere effettuata istantaneamente cioè ogniqualvolta una parola binaria coincide con

una parola di codice l’M-messaggio corrispondente si può dare per identificato, non

essendo possibile alcuna ambiguità.

3.3 - Lunghezza Media di un Codice.

Note le caratteristiche della sorgente e fissata la lunghezza del messaggio da

codificare e detto ( ) il numero di bit che costituiscono la parola binaria ( ) che il

codice associa all’M-messaggio , ad ogni codice si può associare una lunghezza

media della parola di codice:

∑ ( ) ( )

A

(3.3.1)

ne discende che il numero medio di bit utilizzati per ciascun simbolo emesso dalla

sorgente è pari a

.

La conoscenza di tale dato è importante in quanto ci permette ad esempio di

stimare con buona approssimazione lo spazio di memoria necessario per archiviare un

file “tipico” costituito da un numero sufficientemente grande di simboli emessi dalla

sorgente .

Dal nostro punto di vista un codice di sorgente è tanto migliore quanto minore è

la sua lunghezza media a patto che ovviamente la sua decodifica non risulti troppo

onerosa.

Esiste un importante teorema che, nel caso di sorgenti DMS stazionarie da un

lato pone un limite inferiore alla lunghezza media ottenibile al variare del codice scelto

e dall’altro garantisce che, se si è disposti ad accettare una maggiore complessità nei

processi di codifica/decodifica è possibile approssimare tale limite bene quanto si

vuole.

La Codifica di Sorgente 21

Per dimostrare tale teorema ci serviremo di una condizione necessaria alla

decodificabilità di un codice di sorgente, a differenza di quella del prefisso che, come

già detto, è invece una condizione sufficiente.

3.4 - La Disuguaglianza di Kraft.

Consideriamo una sorgente DMS con alfabeto di cardinalità ed un generico

codice per gli M-messaggi emessi da essa. Comunque scelto vale l’identità:

( ∑ ( )

A

)

∑ ∑

A

∑ ( ( ) ( ) ( ))

A A

(3.4.1)

la sommatoria ad ultimo membro della precedente può anche essere calcolata

“accorpando” i termini con uguale esponente. A tale scopo indichiamo con la

massima lunghezza raggiunta dalle parole di codice. Il massimo esponente che può

comparire nell’ultimo membro della (3.4.1) vale quindi . Ciò premesso, possiamo

scrivere:

( ∑ ( )

A

)

∑

(3.4.2)

essendo il numero di stringhe di bit che si possono ottenere giustapponendo

parole di codice.

Se pretendiamo che il codice sia univocamente decodificabile, dovrà neces-

sariamente essere , se così non fosse, esisterebbero certamente almeno due

sequenze di M-messaggi codificate con la stessa stringa binaria di bit.

La considerazione fatta suggerisce per la (3.4.2) la seguente maggiorazione:

( ∑ ( )

A

)

∑

∑

(3.4.3)

Osserviamo che la precedente deve valere per ogni e, visto che il primo membro, se

crescesse con lo farebbe esponenzialmente, non può essere soddisfatta a meno che

non risulti

∑ ( )

A

(3.4.4)

la precedente va sotto il nome di Disuguaglianza di Kraft ed in quanto condizione

necessaria all’univoca decodificabilità costituisce un vincolo sulla distribuzione delle

lunghezze delle parole d’un codice.

Esempio 3.1

Premesso che:un grafo è definito da una coppia d’insiemi ( );


- l’insieme è detto insieme dei vertici ;

- l’insieme è detto insieme dei lati e definisce una relazione (detta di adiacenza)

su

- a ciascun vertice di un grafo si può associare un grado definito come il numero di lati in cui

esso appare;

- un percorso di lunghezza è definito come una sequenza di vertici , tali che

( ) , ;

- un grafo è detto connesso se comunque scelti due vertici distinti esiste un percorso tra essi;

- un ciclo è un percorso in cui il primo e l’ultimo vertice coincidono;

- un albero è un grafo connesso senza cicli;

- in un albero i nodi di grado uno sono detti foglie;

- un albero ha radice se uno dei vertici viene etichettato come tale;

- un albero binario è un albero con radice in cui nessun vertice ha grado maggiore di tre e la

radice ha grado non maggiore di due;

- per ordine di un vertice si intende la lunghezza del percorso che lo connette alla radice, i

vertici di ordine adiacenti ad un nodo di ordine sono detti figli ed il vertice che li

connette è detto padre.

Un metodo per costruire un codice che soddisfi la regola del prefisso è definire un albero binario

avente foglie ed associare ai vertici stringhe binarie di lunghezza pari al loro ordine secondo le

seguenti regole:

- alla radice si associa la stringa vuota

- ai vertici figli si associano stringhe distinte ottenute a partire da quelle associate ai vertici

padri, giustapponendovi rispettivamente i simboli ‘0’ ed ‘1’.

Al termine della costruzione, le foglie dell’albero hanno associate parole di codice che

soddisfano la regola del prefisso. E’ utile notare che la diseguaglianza di Kraft è soddisfatta per

costruzione. In particolare lo è come uguaglianza nel caso in cui il numero di vertici dell’albero sia

.

3.5 - Limite Inferiore per la Lunghezza di un Codice.

Forti del precedente risultato consideriamo la seguente funzione del generico M-

messaggio

( ) ( )

∑ ( ) A

(3.5.1)

( ) soddisfa tutte le condizioni per poter essere la dmp di una M-upla di variabili

aleatorie discrete che assumono valori appartenenti all’alfabeto , pertanto, tenendo

conto della (1.3.6), si può scrivere:

( ) ∑ ( )

( ) A

∑ ( )

( ) A

∑ ( )

( )

A

∑ ( ) ∑ ( )

A A

∑ ( ) ( )

A

( ∑ ( )

A

) ( ∑ ( )

A

)

(3.5.2)

La disuguaglianza di Kraft ci garantisce che il logaritmo all’ultimo membro della

precedente non è positivo, se ne conclude che vale la disuguaglianza

( ) (3.5.3)

che, se la sorgente è stazionaria, comporta:


( )

(3.5.4)

La precedente ci fa capire che, non possono esistere codici univocamente de-

codificabili che utilizzano un numero medio di bit per simbolo minore dell’entropia

della sorgente da codificare. Esiste quindi un limite inferiore alla possibilità di

“comprimere”, senza perdite, le informazioni emesse dalla sorgente, a prescindere dalla

complessità del codificatore, che come s’intuisce, tipicamente cresce al crescere di .

La (3.5.4) ha anche il merito di chiarire meglio l’importanza dell’entropia nell’ambito

della Teoria dell’Informazione.

Esempio 3.2

Un algoritmo ricorsivo per la costruzione di un codice di sorgente ottimo nel senso della

lunghezza media delle parole è dovuto ad Huffman (1952).

L’algoritmo di Huffman consiste nella costruzione ricorsiva di un albero binario. Ricordando che

l’obiettivo è ottenere la minore lunghezza media possibile, si intuisce che a simboli meno probabili

devono corrispondere parole di codice aventi lunghezza maggiore, ovvero foglie aventi ordine

maggiore.

Per costruire l’albero si deve disporre delle probabilità ( ) di manifestazione degli

messaggi . L’albero costruito dall’algoritmo di Huffman ha vertici: i primi sono

associati alle probabilità , mentre i restanti vengono determinati ricorsivamente. A ciascun

vertice viene associata una variabile booleana che ne indica l’utilizzo da parte dell’algoritmo.

Al passo -esimo, si procede come segue:

si scelgono tra i vertici non ancora marcati come utilizzati i due vertici e aventi le

probabilità associate minori, si marcano e come utilizzati e si introduce un nuovo vertice

avente probabilità associata pari a si aggiungono all’insieme dei lati i due elementi

( ) e ( ).

Sostanzialmente l’algoritmo può essere riassunto come segue: “inizialmente tutti i vertici sono

orfani; a ciascun passo si scelgono i due orfani aventi probabilità associata minima e li si dota di un

vertice padre (a sua volta orfano) avente probabilità pari alla somma delle probabilità dei figli”.

Al termine dell’algoritmo resta un unico vertice non ancora utilizzato, e lo si denota radice

dell’albero. Una volta costruito l’albero, il codice di Huffman è definito dalla procedura

dell’Esempio 3.1.

Come esempio, consideriamo la costruzione di un codice di Huffman per una sorgente DMS

stazionaria avente alfabeto e probabilità di emissione e .

Essendo la sorgente binaria, con il codice contiene due sole stringhe ‘0’ ed ‘1’; la

lunghezza media del codice risulta , mentre l’entropia è data da ( ) Con , gli M-messaggi possibili sono quattro, caratterizzati

dalle probabilità di emissione , , e ; l’albero costruito

secondo l’algoritmo di Huffman è riportato in Fig.E 3.1.

La lunghezza media del codice risulta ( ) ed il numero

medio di bit utilizzati per simbolo ( ), in accordo con la (3.5.4).

Fig.E 3.1 - Albero e codice di Huffman associato al codice con M = 2


3.6 - La Proprietà di Equipartizione.

Occupiamoci adesso di un’importante proprietà delle sorgenti d’informazione.

Consideriamo una DMS stazionaria con entropia ( ) , fissiamo un e,

nell’insieme di tutti gli M-messaggi, prendiamo in considerazione il sottoinsieme

S così definito

( ( ) )

( ) ( ( ) ) (3.6.1)

Dalla precedente discende innanzi tutto che:

∑ ( ( ) )

S

∑ ( )

S

(3.6.2)

Dalla quale deduciamo che la cardinalità di S non può essere maggiore di ( ( ) )

quindi tutti i messaggi appartenenti ad S possono essere codificati utilizzando parole

di codice di lunghezza fissa con un numero di bit non superiore a:

( ( ) ) (3.6.3)

Tenendo conto del fatto che la sorgente è per ipotesi priva di memoria si può anche

scrivere:

( ( ) ) ∑

( )

( ( ) )

( ) ∑ ( ( ))

(3.6.4)

Dall’ultimo membro della precedente si può facilmente estrapolare la definizione

dell’insieme , cioè del complementare di S rispetto all’insieme degli M-messaggi:

|∑ ( ( ))

( )| (3.6.5)

Ci proponiamo di maggiorare la probabilità dell’evento: “la sorgente ha emesso un

messaggio appartenete a ”. A tal fine ricordiamo che la disuguaglianza di Chebyshev

garantisce che la probabilità che una V.A. con varianza disti dal suo valore medio

per più di è non maggiore di

.

Osserviamo che ∑ ( ( ))

può essere interpretata come una V.A. ottenuta

sommando le variabili aleatorie statisticamente indipendenti ( ( )) tutte

identicamente distribuite. Osserviamo che il valor medio di ciascuna di esse vale

( ) quindi il valor medio di vale:


(∑ ( ( ))

) ( ) (3.6.6)

Anche la varianza di è volte la varianza di ( ) e vale:

∑( ( ( )) ( )) ( )

(3.6.7)

In conclusione, ponendo , la probabilità che un M-messaggio appartenga

ad sarà non maggiore di

( S )

∑ ( ( ( ( ))) ( )) ( ( ))

(3.6.8)

La disuguaglianza appena scritta ci dice che la probabilità che un M-messaggio

non appartenga a S tende a zero al tendere di all’infinito.

In altri termini abbiamo appena mostrato che “asintoticamente” i messaggi

emessi da una sorgente possono essere suddivisi in due classi la prima contiene

messaggi sostanzialmente equiprobabili con probabilità di manifestarsi ( ), la

seconda contenente messaggi che si presentano con probabilità prossima a zero.

La proprietà appena descritta, che vale anche per sorgenti dotate di memoria, va

sotto il nome di proprietà di equipartizione (equipartition property).

Tra l’altro essa ci dice che, pur di considerare messaggi sufficientemente lunghi,

il numero di messaggi distinti che una sorgente emette è approssimativamente pari a

( ) che rappresenta solo una frazione degli teoricamente generabili.

Il fatto che esista un sottoinsieme di messaggi aventi un’esigua probabilità di

manifestarsi può essere utilmente sfruttato nel caso in cui si vogliano mettere a punto

dei sistemi di codifica che accettino una qualche perdita nel contenuto informativo. Si

potrebbe ad esempio pensare di progettare un codificatore di sorgente che ignori i

messaggi poco probabili. Ciò porterebbe a una perdita d’informazione che potrebbe

però essere trascurabile rispetto a quella che si perderebbe comunque a causa ad

esempio degli errori introdotti dal sistema di trasmissione.

3.7 - Teorema sulla Codifica di una Sorgente DMS.

Abbiamo visto che la (3.5.4) impone un limite inferiore alla lunghezza media del

codice, ma, la stessa, nulla ci dice su quanto a detto limite ci si possa avvicinare.

Per rispondere a questo quesito utilizzeremo la proprietà di equipartizione

introdotta nel paragrafo precedente al fine di costruire un codice univocamente

decodificabile per gli M-messaggi emessi dalla sorgente.


Fissiamo ad arbitrio un , possiamo utilizzare il primo bit (binary digit) della

parola del costruendo codice per classificarla come appartenente o meno all’insieme S

definito nel precedente paragrafo. Osserviamo quindi che, per identificare

univocamente tutti gli elementi di S , sulla base della (3.6.3), saranno sufficienti

ulteriori S ( ( ) ) bit. Restano da codificare gli elementi appartenenti

ad . A tal fine ricordiamo che tali elementi hanno una probabilità molto piccola di

manifestarsi, quindi incidono poco sulla lunghezza media del codice che è la quantità

che ci interessa limitare. Ciò premesso possiamo utilizzare per codificarli un numero di

bit , laddove bit sarebbero sufficienti a codificare tutti gli

M-messaggi.

In sostanza la generica parola di codice avrà lunghezza S o

, e non vi è

nessuna ambiguità per il decodificatore che osservando il primo bit di ogni parola

saprebbe quale è la sua lunghezza. Ciò ovviamente è vero solo se il codificatore e il

decodificatore sono esenti da errori.

Calcoliamo adesso lunghezza media per simbolo emesso dalla sorgente del

codice che abbiamo appena costruito:

( S

( S ) ( )) (3.7.1)

che, tenuto conto della (3.6.8), si può maggiorare come segue:

( S

( S ) ( ))

( S

( S ))

( S

)

( ( ( ) ) ) ( )

( ( ) ) ( )

( )

(3.7.2)

Si osservi che può essere scelto arbitrariamente, in particolare possiamo

scegliere

ottenendo:

( )

(

) (3.7.3)

Osserviamo adesso che nell’ultimo membro della (3.7.3) tutti gli addendi eccetto il

primo tendono a zero al crescere di , possiamo quindi scriverla nella forma:

( ) ( ) (3.7.4)


La precedente è molto importante perché ci permette di affermare che per le

DMS, accettando eventualmente una complessità elevata di codifica/decodifica, si può

costruire un codice che usa un numero medio di bit per simbolo prossimo quanto si

vuole all’entropia della sorgente.

In conclusione mettendo insieme la (3.5.3) e la (3.7.4) abbiamo dimostrato il

seguente

Teorema 3.1

Data una DMS stazionaria con entropia ( ) e comunque scelto , esiste un

intero in corrispondenza al quale si può costruire un codice univocamente

decodificabile che esibisce una lunghezza media per simbolo di sorgente che soddisfa

la seguente disuguaglianza:

( )

( ) (3.7.5)

Inoltre, qualunque sia , non è possibile costruire codici per i quali risulti:

( ) (3.7.6)

***********

Vale la pena di osservare che il codice che abbiamo costruito, se da un lato c’è

stato utile per ottenere la (3.7.5), dal punto di vista pratico sarebbe difficilmente

applicabile perché presuppone la conoscenza della dmp della sorgente, dato questo di

cui in pratica difficilmente si dispone. Esistono algoritmi di codifica che tendono al

limite inferiore imposto dalla (3.7.5) pur non presupponendo la conoscenza della dmp

in parola, e che quindi si rivelano molto più utili in pratica.

Esempio 3.3

L’algoritmo di Huffman descritto nell’Esempio 3.2 richiede la conoscenza a priori delle

probabilità dei simboli di sorgente. Descriviamo brevemente un possibile metodo per ottenere una

versione adattativa dell’algoritmo che presuppone solo la conoscenza della cardinalità dell’alfabeto

.

L’idea è riassumibile in due punti:

- utilizzare, invece delle probabilità di manifestazione, le frequenze relative di manifestazione

dei simboli di sorgente, inizializzate con una distribuzione a priori nota a codificatore e

decodificatore

Fig.E 3.2 - Schema a blocchi di un generico codec (codificatore/decodificatore) adattativo.


- non aggiornare la tabella delle frequenze relative di apparizione dei simboli fintanto che il

decodificatore non li ha potuti osservare.

Lo schema di riferimento dell’algoritmo adattativo (che è di carattere generale) è riportato in

Errore. L'origine riferimento non è stata trovata..

Si noti che così descritto, questo metodo richiede nella peggiore delle ipotesi la ricostruzione

(previa verifica di consistenza) dell’albero di Huffman per ogni simbolo trasmesso, il che può essere

impraticabile. Inoltre, l’algoritmo adattativo così formulato è basato sull’assunzione che le frequenze

relative convergano in tempi brevi alle probabilità di manifestazione dei simboli; per “brevi” si

intende rispetto al tempo durante il quale si può assumere che la sorgente sia effettivamente

stazionaria.

In Fig.E 3.3 è mostrato l’andamento temporale della lunghezza (media) del codice per un

codificatore adattativo che elabora simboli quaternari caratterizzati dalle probabilità di

manifestazione , , e , al variare della lunghezza degli

M-messaggi; l’entropia della sorgente è pari a ( ) .

3.8 - Codifica di Sorgenti con Memoria.

Una sorgente è detta con memoria quando la probabilità di emissione di un

simbolo dipende dalla sequenza di simboli emessa in precedenza:

( ) ( ) (3.8.1)

Come puntualizzato al termine del capitolo precedente, per una sorgente discreta

con memoria l’entropia di un M-messaggio è minore dell’entropia della sorgente

riguardata come senza memoria. Ciò implica che codificare una sorgente con memoria

con metodi che possono essere ottimi nel caso di sorgenti DMS può risultare ben

lontano dall’ottimo.

Fig.E 3.3 - Andamento temporale (blu), al variare di M, della lunghezza media del codice prodotto dal

codec adattativo di Fig.E 3.2 per la sorgente DMS dell’Esempio 3.3. In rosso l’entropia stimata in base

alle frequenze relative.

Fig.E 3.3 - Andamento temporale (blu), al variare di M, della lunghezza media del codice prodotto dal

codec adattativo di Fig.E 3.2 per la sorgente DMS dell’Esempio 3.3. In rosso l’entropia stimata in base

alle frequenze relative.


Si potrebbe osservare che la proprietà di equipartizione, valida anche per sorgenti

con memoria, permette di affermare che la codifica senza memoria di M-messaggi è,

asintoticamente per , ottima; d’altra parte l’impiego di valori di M maggiori di

qualche unità è quasi sempre proibitivo.

L’approccio utilizzato in pratica per la codifica di sorgenti con memoria consiste

nell’operare una forma di pre-codifica allo scopo di rendere il più possibile incorrelata

la sorgente. Riportiamo di seguito alcuni esempi didattici che s’ispirano a metodi

impiegati nella pratica.

Esempio 3.4

Nel caso di sorgenti discrete ottenute tramite campionamento di segnali a valori discreti (si pensi

ad esempio ad una scansione FAX), si può impiegare la codifica run-length (RLE).

L’idea alla base della RLE è sostituire sequenze costituite da simboli identici con una indicazione

di quale simbolo viene ripetuto quante volte. Ad esempio, la codifica run-length della sequenza:

A, A, A, A, A, B, B, B, B, B, B, C, C, C, C, A, A, B, B, B, B, B, C, C, C

è data da:

(A,5), (B,6), (C,4), (A,2), (B,5), (C,3).

Per valutare l’efficienza della codifica run-length si deve tenere conto dell’overhead richiesto per

codificare la lunghezza dei run. Per ottenere qualche numero tangibile, consideriamo la piccola

immagine in bianco e nero (32 righe, 128 colonne) in Fig.E 3.4.

Questa immagine, riguardata come una sequenza di simboli binari emessi da una sorgente DMS,

ha una entropia di 0.5871 bit/simbolo (578 pixel neri, 3518 pixel bianchi), ovvero un contenuto

informativo stimato di 2405 bit.

Se codificata RLE per colonne con lunghezza massima dei run pari a 511, è rappresentata da 313

run aventi una entropia stimata di 4.582 bit/run ovvero un contenuto informativo complessivo non

inferiore a 1435 bit (con un guadagno potenziale del 65% rispetto alla dimensione non codificata di

4096 bit).

Si deve però notare che la lunghezza massima dei run è un parametro problematico da impostare,

in quanto se, da una parte, incrementandolo il numero complessivo di run diminuisce, dall’altra il

numero di bit necessario a codificare la lunghezza di un singolo run aumenta, sicché per immagini di

piccola dimensione come questa l’effettivo guadagno può risultare marginale.

Da segnalare che per la codifica di immagini in bianco e nero (ad. esempio FAX), esistono

generalizzazioni bidimensionali della codifica run length, che sfruttano le correlazioni esistenti tra le

righe.

Esempio 3.5

Nel caso di sorgenti

discrete generiche esi-

stono molti metodi, nes-

suno dei quali ottimo.

Un approccio utilizzato

nella codifica di sorgen-

te di dati correlati è

quello a dizionario. Il

più diffuso algoritmo di

codifica di sorgente a

dizionario è il Lempel-Ziv (del 1977, LZ77), implementato in molte utility “zip” (pkzip, winzip,

infozip, gzip, compress e altre).

L’idea della codifica LZ77 è sostituire, nella sequenza originaria, a sequenze di simboli già

incontrate una indicazione di “a partire da dove” e “per quanti simboli” è possibile copiarle. Per

chiarire, consideriamo la codifica LZ77 della sequenza dell’Esempio 3.4

(A,1,4), (B,1,5), (C,1,3), (A,11,6), (C,1,2).

Il primo blocco, (A,1,4), viene decodificato come: “dopo un simbolo A, torna indietro di un passo

e copia per quattro volte”, ovvero una sequenza di cinque simboli A. Il secondo blocco ed il terzo

blocco sono analoghi al primo. Per comprendere come viene interpretato il quarto blocco, notiamo

che dopo i primi tre blocchi il decodificatore avrà prodotto la sequenza:

Fig.E 3.4 - Immagine (ingrandita in modo da evidenziare i singoli pixel) per l’esempio di codifica run-length (32x128x1).


A, A, A, A, A, B, B, B, B, B, B, C, C, C, C.

A questo punto, aggiungere un simbolo A, tornare indietro di undici passi e copiare per sei volte

corrisponde ad aggiungere la sequenza A, B, B, B, B, B, C in coda. L’ultimo blocco è di tipo run-

length come i primi tre.

La codifica LZ77 dell’immagine in bianco e nero di Fig.E 3.4 è una sequenza di solo 60 triplette

aventi una entropia stimata di 11.52 bit ciascuna, per un contenuto informativo complessivo non

minore di 692 bit (con un guadagno potenziale dell’83% sulla dimensione non codificata di 4096

bit).

Capitolo - 4

CANALI PRIVI DI MEMORIA

4.1 - L’Informazione Mutua.

Consideriamo un generico esperimento casuale. Abbiamo detto che al mani-

festarsi di un dato evento E è associata una quantità d’informazione

(E ); la stessa

quantità può essere interpretata come la nostra incertezza sull’evento E . Ad esempio

se (E ) allora sul fatto che E si manifesti non abbiamo nessuna incertezza ed in

questo caso si avrebbe

(E ) nel caso in cui (E ) fosse molto piccola

avremmo una grande incertezza sul fatto che E si possa manifestare, ed acquisiremmo

quindi una grande informazione qualora si manifestasse.

Consideriamo adesso una coppia d’eventi E , E , il manifestarsi di E può

variare la nostra incertezza su E se ad esempio E E il manifestarsi di E

rimuoverebbe tutta l’incertezza

(E ) che a priori avevamo su E . Se, viceversa, i

due eventi fossero statisticamente indipendenti il manifestarsi di E lascerebbe

immutata l’incertezza che a priori avevamo su E .

In altri termini se sapessimo che E è verificato il manifestarsi di E ci fornirebbe

un’informazione in genere diversa da quella che avremmo avuto a priori (cioè senza

saper nulla circa E ). In particolare l’informazione fornita a posteriori (cioè sapendo

che E è verificato) dal manifestarsi di E varrebbe

(E E ).

Si definisce informazione mutua (E E ), l’incertezza che rimarrebbe sull’e-

vento E qualora E si manifestasse. In formule:

( )

( )

( )

( )

( ) (4.1.1)

Alla luce della definizione appena data la scelta del nome Informazione mutua

può apparire infelice, esso probabilmente trae origine dal fatto che ricordando la regola

di Bayes possiamo scrivere:

( ) ( )

( ) ( )

( )

( ) ( ) (4.1.2)

Osserviamo che, nel caso in cui E E , (E E ) varrebbe

(E ) cioè E ci

fornirebbe su E tutta l’informazione che ci potrebbe fornire E stesso. E cioè

rimuoverebbe ogni incertezza su E . Viceversa se (E E ) ( E ) ( E ) allora


(E E ) che sta a significare che il manifestarsi di E non modificherebbe

l’incertezza su E .

È anche opportuno sottolineare che (E E ) può assumere anche valori negativi,

ciò da conto del fatto che il manifestarsi di E potrebbe rendere molto più incerto, se

non impossibile il manifestarsi di E .

4.2 - Concetto di Canale.

Come già detto, un sistema di trasmissione ha la finalità di inviare un messaggio

da un emissario a un destinatario in luoghi o tempi diversi. Per recapitare il messaggio,

il sistema si gioverà di un mezzo trasmissivo che viene abitualmente chiamato canale.

Il concetto di canale è piuttosto ampio, nel senso che esso può includere, a seconda

delle necessità, o solo il mezzo fisico, ad esempio il solo doppino telefonico o un nastro

magnetico, o anche tutto ciò che è compreso tra un microfono e un altoparlante.

Nel caso ad esempio di un sistema di trasmissione numerico modulato line-

armente, si può pensare che il canale includa, modulatore, amplificatore RF, mezzo

fisico, amplificatore d’ingresso, eventuale demodulatore a frequenza intermedia,

demodulatore, filtri adattati e campionatori. In questo caso il canale accetterà in

ingresso un numero complesso appartenente a una data costellazione e fornirà in uscita

un numero complesso che in genere differisce da quello inviato per effetto del rumore e

dei disturbi introdotti dal mezzo e dagli apparati. Se decidessimo di includere nel

canale anche il decisore, l’uscita del canale sarebbe si un punto della costellazione, ma

come sappiamo non sempre lo stesso che si era inviato.

Qui ci limitiamo a considerare canali di tipo discreto che sono caratterizzati da un

alfabeto d’ingresso e da uno d’uscita , legati da un mapping aleatorio.

In pratica non si lede la generalità se si pensano ingresso e uscita come una

coppia di variabili aleatorie definite sullo stesso esperimento casuale.

Se l’alfabeto d’ingresso e quello d’uscita hanno rispettivamente cardinalità ed

e se e

sono i rispettivi alfabeti, il canale è univocamente

individuato quando sono note le seguenti dmp condizionate:

( | ) ( | ) (4.2.1)

Risulta spontaneo pensare alle come agli elementi di una matrice con un

numero di righe pari alla cardinalità dell’alfabeto di ingresso e un numero di colonne

uguale alla cardinalità di quello d’uscita. Chiameremo matrice di transizione di

canale.

Canali Discreti Privi di Memoria 33

Nel caso in cui l’alfabeto d’ingresso è finito e quello d’uscita ha la potenza del

continuo il canale è caratterizzato se si conoscono le seguenti densità di probabilità

condizionate:

( | ) ( | ) (4.2.2)

Si dice che il canale è privo di memoria se, la probabilità di rivelare un

data sequenza di M simboli d’uscita in corrispondenza ad un dato M-messaggio di

ingresso è data da

( [ ] | [ ]) ∏ ( )

(4.2.3)

se l’alfabeto d’uscita è finito.

Ovvero la densità di probabilità della sequenza d’uscita condizionata ad una

sequenza d’ingresso è data da:

( ) ∏ ( )

(4.2.4)

nel caso in cui l’alfabeto d’uscita ha la potenza del continuo.

Se in ingresso al canale è connessa una sorgente che emette simboli compatibili

con il canale, e se sono note le probabilità d’emissione ( ) di ciascun

simbolo dell’alfabeto di sorgente dalle (4.2.1) e (4.2.2) possiamo dedurre la

distribuzione di massa di probabilità dell’alfabeto d’uscita del canale, cioè dei simboli

:

( ) ∑

(4.2.5)

ovvero la densità di probabilità della V.A. d’uscita:

( ) ∑ ( )

(4.2.6)

Consideriamo un canale discreto e privo di memoria (DMC - Discrete Me-

moryless Channel).

Se in uscita rilevassimo il simbolo l’incertezza residua sull’emissione del

generico simbolo d’ingresso varrebbe:

(

)

(4.2.7)

che ricordando la (4.1.2) è uguale a


( )

( )

(4.2.8)

mediando su tutte le possibili coppie ingresso uscita otteniamo una misura dell’in-

certezza che mediamente ci rimane sul simbolo in ingresso dopo aver osservato il

corrispondente simbolo in l’uscita. Abbiamo appena definito l’informazione mutua

media:

( ) ∑ ∑ ( ) ( )

( )

∑ ∑ ( )

( | )

( )

∑ ∑ ( )

(4.2.9)

sostituendo nella precedente la (4.2.5) otteniamo ancora:

( ) ∑ ∑

∑

(4.2.10)

Sebbene l’informazione mutua (4.2.8) possa assumere anche valori negativi così

non è per l’informazione mutua media (4.2.9), risulta infatti:

( )

∑ ∑

∑ ∑ (

)

∑ ∑ ( )

[∑ ∑

∑ ∑ ( )

]

(4.2.11)

Osservando la (4.2.10) ci rendiamo conto che l’informazione mutua non dipende

solo dal canale, ma anche dalla dmp della sorgente. Al fine di fornire una grandezza

caratteristica del solo canale si procede alla ricerca del massimo della (4.2.10) al variare

delle distribuzioni di massa di probabilità della sorgente. Otteniamo

così la cosiddetta capacità di canale:

I( ) (4.2.12)

che, come vedremo, gioca un ruolo fondamentale nel

dimensionamento di un sistema di trasmissione.

La ricerca del suddetto massimo, dato il tipo di

dipendenza da non è in genere semplice.

4.3 - Il Canale Simmetrico Binario.

Si consideri un canale schematizzato in Fig.E 4.1

che accetta ed emette simboli appartenenti a un alfabeto binario sorgente che emette

Fig.E 4.1 - Canale Simmetrico Bi-

nario


simboli appartenenti a un alfabeto binario costituiti cioè rispettivamente da due soli

simboli, , ; la matrice di transizione a esso associata sarà quindi una

che se risulta è simmetrica e caratterizza un BSC (Binary

Simmetric Channel).

|

| (4.3.1)

Se il canale è connesso a una sorgente che emette simboli con probabilità ,

risulta:

( ) ( ) ( )( )

(4.3.2)

L’informazione mutua media di un BSC varrà quindi:

( ) ∑ ∑

∑ ∑

∑ ∑

∑ ∑

∑

( ) ( ) ( )

( )( ) ( ) ∑

( ) ( ) ∑

( ) ( )

(4.3.3)

Dalla precedente si evince facilmente che la

capacità di canale si ottiene massimizzando l’en-

tropia dell’uscita ( ), che, come già visto, lo é

quando i simboli d’uscita sono equiprobabili, cosa

che, data la simmetria del canale, avviene quando

lo sono quelli emessi dalla sorgente. Concludiamo

che la capacità di un BSC vale:

( ) (4.3.4)

(vedi Fig.E 4.2).

È interessante osservare che

implicherebbe che da conto del fatto

che in questo caso il canale sarebbe ovviamente del tutto inutile ai fini del trasferimento

d’informazione.

4.4 - Capacità del Canale AWGN a Banda

Limitata.

Consideriamo adesso il canale con ingresso e

uscita ad alfabeto continuo rappresentato in Fig.E 4.3

Fig.E 4.3 - Canale Gaussiano

Fig.E 4.2 - Capacità del canale simmetrico

binario


esso aggiunge alla variabile aleatoria generata dalla sorgente un disturbo costituito da

una variabile aleatoria Gaussiana a media nulla e varianza , statisticamente

indipendente dalla variabile aleatoria in ingresso.

L’informazione mutua associata al canale in questione è data da:

( ) ( ) ( )

∫ ( )

( )

∫ ∫ ( )

( )

∫ ( )

( )

∫ ( )∫ ( )

( )

(4.4.1)

Osserviamo che ( )

√

( )

in quanto differisce da per il solo

disturbo che abbiamo detto essere Gaussiano. Sostituendo nella (4.4.1) e ricordando

la (2.2.3) otteniamo:

( ) ∫ ( )

( )

∫ ( )

(

)

∫ ( )

( )

(

)

(4.4.2)

la capacità del canale in parola si ottiene quindi massimizzando l’integrale ad ultimo

membro della precedente, cioè l’entropia dell’uscita. Sappiamo (vedi § 2.2 - ) che il

massimo dell’entropia, a parità di varianza, si ottiene da una sorgente Gaussiana.

Affinché la ( ) sia Gaussiana, deve esserlo la variabile aleatoria . In questo

caso indicata con la sua varianza, in virtù dell’indipendenza tra ed si ha:

(4.4.3)

La capacità del canale Gaussiano è quindi data da:

( )

( ( ))

(

)

(

)

(

)

(

)

(4.4.4)

Consideriamo adesso il canale AWGN (Addittive White Gaussian Noise) (vedi

Fig.E 4.4) cioè un canale con ingresso e uscita a tempo continuo che agisce sul segnale

d’ingresso sommando a quest’ultimo un segnale

stazionario Gaussiano a media nulla e densità spettrale di

potenza bilatera costante pari ad

Come sappiamo ogni sistema di trasmissione è

affetto quantomeno dal rumore termico che si può modellare proprio con un processo

Gaussiano bianco.

Fig.E 4.4 - Canale AWGN


Osserviamo adesso che ogni sistema d’interesse pratico tratta di fatto segnali a banda

limitata. Pertanto per limitare la potenza di rumore introdotta ogni canale di fatto viene

limitato in banda tramite un apposito filtro posto tipicamente in ingresso al ricevitore.

Se indichiamo con la banda del segnale sappiamo che esso può essere ricostruito a

partire dai suoi campioni purché ne vengano prelevati almeno al secondo. Il canale

AWGN equivale quindi a un canale Gaussiano utilizzato con la stessa cadenza. La

varianza dei campioni del segnale coinciderà quindi con la potenza media del segnale, e

quella del rumore con la frazione di potenza di quest’ultimo contenuta nella banda del

segnale risulta quindi:

( )

(4.4.5)

dove ( ) rappresenta la potenza del segnale e indica la densità spettrale di potenza

monolatera del rumore. Sostituendo nella (4.4.4) otteniamo:

(

( )

) (4.4.6)

La precedente indica la capacità del canale AWGN limitato in banda per uso del canale,

espressa quindi in bit. In pratica è più utile esprimere la capacità in termini di bit al

secondo, in questo caso a partire dalla precedente è sufficiente osservare che il canale

viene utilizzato volte al secondo. La capacità espressa in bit/sec del canale in

questione vale quindi:

( ( )

) (4.4.7)

Osserviamo che nella (4.4.7) appare il rapporto segnale rumore. La precedente ci dice

che per aumentare la capacità di un canale a tempo continuo possiamo aumentarne il

rapporto segnale rumore o aumentarne la banda, tenendo però presente che un aumento

della banda, a parità di potenza del segnale, comporta un deterioramento del rapporto

segnale rumore.

4.5 - Informazione Mutua tra M-messaggi.

Consideriamo un DMC. Utilizzando le dmp congiunte, possiamo facilmente

definire l’informazione mutua tra M-messaggi in ingresso e in uscita.

( ) ∑ ∑ ( ) ( )

( )

(4.5.1)

la precedente può anche essere riscritta:

( ) ∑ ( )

( )

∑ ∑ ( )

( )

(4.5.2)


e, ricordando la (1.3.6), può essere maggiorata come segue:

( ) ∑ ( )

∏ ( )

∑ ∑ ( )

( )

∑ ∑ ( ) ( ) ∏ ( )

( )

∑ ∑ ( ) ( ) ∑ ( )

( )

∑ ∑ ∑ ( ) ( ) ( )

( )

∑ ( )

(4.5.3)

L’uguaglianza vale se i simboli d’uscita sono mutuamente statisticamente indipendenti

perché in questo caso si avrebbe ( ) ∏ ( )

. Questa condizione è certamente

soddisfatta se la sorgente è priva di memoria.

Se la sorgente ed il canale sono stazionari tenuto conto della (4.2.12) possiamo

ulteriormente scrivere:

( ) ∑ ( )

( ) (4.5.4)

4.6 - Canali in Cascata.

Consideriamo adesso il caso di due canali in cascata (vedi Fig.E 4.5).

Supponiamo che l’alfabeto d’uscita del primo canale coincida con quello d’ingresso del

secondo, e che l’uscita di ciascun canale dipenda esclusivamente dal suo ingresso. Ciò

significa che

( ) ( ) (4.6.1)

Facendo sempre riferimento alla figura, consideriamo la differenza tra le infor-

mazioni mutue ( )ed ( ). Si ha:

Fig.E 4.5 - Canali in cascata


( ) ( ) ∑ ( ) ( )

( )

∑ ( ) ( )

( )

∑ ( ) ( ) ( )

( ) ( )

∑ ( ) (

( ) ( )

( ) ( ) )

(∑

( ) ( ) ( )

( ) ( )

( ))

(∑

( ) ( ) ( ) ( )

( ) ( )

( ))

(∑

( ) ( ) ( )

( )

( ))

(∑ ( ) ( ) ( )

( ))

(∑ ( ) ∑ ( )

)

(∑ ( )

)

(4.6.2)

In definitiva abbiamo mostrato che se si collegano due, o, ovviamente, più canali

in cascata l’informazione mutua tra ingresso e uscita può solo diminuire. Il risultato

appena ottenuto vale anche nel caso in cui si colleghino in cascata al canale dei sistemi

deterministici, come ad esempio un codificatore in ingresso e\o un decodificatore

d’uscita.

Consideriamo (vedi Fig.E 4.6) il caso di una DMS connessa a un codificatore che

opera in modo deterministico su M-messaggi emessi dalla sorgente per generare

sequenze di lettere compatibili con un DMC con alfabeti d’ingresso e d’uscita della

stessa cardinalità . L’uscita del canale è poi connessa a un decodificatore che opera in

modo deterministico sugli L-messaggi emessi dal canale per “cercare” di ricostruire gli

M-messaggi emessi dalla sorgente. Ovviamente una condizione sufficiente affinché in

uscita venga ricostruito correttamente il messaggio è che il canale non abbia introdotto

disturbi tali da indurre il decodificatore in errore.

Fig.E 4.6


Assumiamo inoltre che le durate dell’M-messaggio emesso dalla sorgente e del

corrispondente L-messaggio in uscita al codificatore siano uguali, pertanto se la sor-

gente emette lettere con una cadenza regolare la cadenza dei simboli in ingresso al

canale sarà data da:

(4.6.3)

Con riferimento alla Fig.E 4.6 considerando l’informazione mutua ( ) , tenuto

conto della (4.6.2) possiamo scrivere:

( ) ( ) ( ) (4.6.4)

dove è la capacità relativa ad una coppia di simboli ingresso/uscita del canale.

4.7 - L’Inverso del Teorema della Codifica di Canale

È a questo punto opportuno ricordare che il nostro obiettivo nella progettazione

di un sistema di trasmissione è ottenere la minore probabilità d’errore compatibilmente

con dei prefissati vincoli di potenza impiegabile e/o di banda, senza tralasciare

ovviamente la complessità del sistema che, quando non si scontra con barriere tecno-

logiche, ha un forte impatto sui costi.

Facendo sempre riferimento alla Fig.E 4.6 considerando ad esempio la -esima

lettera dell’M-messaggio emesso dalla sorgente, il sistema commette un errore se la -

esima lettera del corrispondente M-messaggio in uscita dal decodificatore non coincide

con quella emessa.

La probabilità che il sistema commetta un errore sulla -esima lettera del

messaggio è quindi uguale alla ( ), che, in termini della dmp congiunta delle

variabili vale:

∑

( )

A

(4.7.1)

La probabilità d’errore appena calcolata dipende in genere dall’indice . Se

volessimo farci un’idea della probabilità d’errore media su un generico simbolo dell’M-

messaggio potremmo calcolare la media aritmetica delle ottenendo:

∑

(4.7.2)

Consideriamo adesso la catena di disuguaglianze:


( ) ( ) ∑ ( )

( ) A

∑ ∑ ( ) ( )

( ) A A

∑ ∑ ( )

( ) A A

∑ ( ( ) ∑ ( )

( ) A

)

A

∑ ( ( ) ∑ ( )

∏ ( | )

A

)

A

∑ ∑ ∑ ( )

( | )

A A

∑ ∑ ∑ ( )

( | ) A A

(4.7.3)

Il nostro scopo è quello di esplicitare il legame tra le grandezze associate all’infor-

mazione e la probabilità d’errore espressa dalla (4.7.1), appare pertanto opportuno

riscrivere la (4.7.3) nella forma:

( ) ( ) ∑

(

∑ ( )

( )

∑ ( )

( )

)

(4.7.4)

Introducendo la probabilità di corretta decisione sul -esimo

simbolo possiamo maggiorare la seconda sommatoria in parentesi nella precedente

come segue:

∑ ( )

( ) A

∑ ( )

( ) A

∑ ( )

( ) A

∑ ( )

A

∑ ( ) (

( ) )

A

∑( ( ) ( ))

A

( )

( )

(4.7.5)

Procedendo in modo analogo sulla prima sommatoria in parentesi nella (4.7.4) si

ottiene anche:


∑ ( )

( ) A

∑ ( ) ( )

( )( ) A

∑ ( )

( )( ) A

∑ ( ) ( )

A

∑ ( ) (

( | )( ) )

A

( )

(

∑ ( )

( | )( ) A

)

( )

(

∑ ( ) ∑

( ) A

A

)

( )

( )

(4.7.6)

dove rappresenta la cardinalità dell’alfabeto . Tenuto conto delle (4.7.5) e (4.7.6) il

primo membro della (4.7.4) può essere quindi ulteriormente maggiorato:

( ) ( ) ∑ [ ( )

( )

( )]

∑[ ( )

( )

( )]

∑ ( ) ( )

( ) ∑ ( )

(4.7.7)

Nella precedente ( ) può essere interpretata come l’entropia di una sorgente binaria

che emette le due lettere che costituiscono il suo alfabeto con probabilità e .

Ricordando la (1.3.6) possiamo ancora scrivere:

( ) ( ) ( ) ∑[

( )

( )]

( )

( )

( ) ( ) ( )

(4.7.8)

Sfruttando il fatto che, per ipotesi, la sorgente è priva di memoria e tenendo in conto la

(4.6.4) abbiamo ancora:

( ) ( ) ( ) ( ) ( ) ( )

( ) (4.7.9)

che, in virtù della (4.6.3), conduce alla:

( ) ( ) ( )

( )

(4.7.10)


Per assegnata cardinalità del-

l’alfabeto di sorgente possiamo tracciare

il grafico della funzione: ( ) (

) ( ).

Come si può notare (vedi Fig.E

4.7) la ( ) pertanto la limitazione

imposta dalla (4.7.10), che per comodità

riscriviamo nella forma:

( ) ( )

(4.7.11)

non avrà alcun effetto fintanto che risulta ( )

o, che è lo stesso, quando

( )

(4.7.12)

cioè fintantoché l’entropia della sorgente espressa in bit al secondo si mantiene minore

della capacità di canale anch’essa espressa in bit al secondo.

Quando viceversa la (4.7.12) non è soddisfatta la (4.7.11) pone un limite inferiore

alla probabilità d’errore ottenibile; saranno cioè compatibili con la (4.7.11) solo valori

di che fanno si che il valore assunto dalla ( ) resti al di sopra della quantità

( )

che nel piano di Fig.E 4.7 è rappresentata da una retta parallela all’asse

delle ascisse, saranno dunque compatibili con la (4.7.11) soltanto valori di probabilità

d’errore che restino alla destra dell’ascissa dell’intersezione di detta retta con la curva

( ).

Quello che abbiamo appena dimostrato è noto come: inverso del teorema della

codifica di canale.

Teorema 4.1

Non è possibile ottenere una probabilità d’errore piccola a piacere all’uscita di un

canale che ha una capacità

se quest’ultima è minore dell’entropia (espressa

sempre in

) della sorgente ad esso connessa.

**********

Purtroppo il teorema appena enunciato nulla ci dice circa la probabilità di errore

effettivamente ottenibile nel caso in cui la capacità del canale sia maggiore dell’entro-

pia della sorgente.

Fig.E 4.7 - 𝐹(𝑃𝑒) (𝑁 )𝑃𝑒 𝐻(𝑃𝑒)

Capitolo - 5

CENNI DI TRASMISSIONE NUMERICA

5.1 - Scenario di Riferimento.

Al fine di introdurre il teorema di Shannon sulla codifica di canale, è opportuno

introdurre alcuni concetti di trasmissione numerica.

Come schema di principio del nostro sistema consideriamo una sorgente che

emette lettere appartenenti ad un alfabeto di cardinalità finita N con una cadenza

di lettere al secondo. La suddetta sorgente è connessa a un codificatore di sorgente

che ogni secondi emette un M-messaggio ( ) ( ) che potremo

pensare come il risultato di un esperimento casuale . ( ) piloterà un codificatore di

canale.

Il codificatore di canale, o modulatore, ha il compito di associare ad ogni ( )

un segnale ( ) ad energia finita, individuato da una funzione reale ( )( ), di durata

non maggiore di , che verrà inviato sul canale, che qui supporremo AWGN (Additive

White Gaussian Noise), cioè un canale che si limita a sommare al segnale un processo

stazionario Gaussiano bianco ( ), con densità spettrale di potenza bilatera costante ,

o, che è lo stesso, con funzione di autocorrelazione ( ) ( ).

Il ricevitore è chiamato, a fornire una stima dell’M-messaggio trasmesso, basan-

dosi sul segnale ricevuto e, ove possibile, sulla conoscenza della statistica di sorgente.

5.2 - Struttura del modulatore e del codificatore di sorgente

Il set di segnali utilizzato dal codificatore di canale sopra citato ha car-

dinalità finita. Esso sarà pertanto contenuto in un sottospazio SK di dimensione

dello spazio dei segnali a energia finita.

Tramite la procedura di ortonormalizzazione di Gram-Smith potremo costruire

quindi una base ortonormale per . Ogni segnale emesso dal modulatore si

può quindi esprimere nella forma:

∑

(5.2.1)

La precedente suggerisce anche uno schema di principio per il codificatore di

sorgente che in sostanza associa a ogni sequenza di lettere emesse dalla

sorgente il vettore

che consente al codificatore di canale

di generare a sua volta tramite la (5.2.1) il segnale da inviare sul canale.

KS


5.3 - Struttura del Ricevitore.

Nell’intervallo (stiamo trascurando il ritardo introdotto dal canale), Il

ricevitore vede al suo ingresso il segnale

(5.3.1)

a energia finita che possiamo pensare come una manifestazione di un segnale aleatorio

.

Il segnale ricevuto può essere scomposto in due segnali: il primo, SK, apparte-

nente al sottospazio SK il secondo, , ortogonale a detto sottospazio.

In particolare avremo

S ∑

(5.3.2)

dove

∫ ( ( ) ( )) ( )

(5.3.3)

Teniamo presente che tutte le funzioni in gioco sono reali e, a parte il rumore,

nulle al di fuori dell’intervallo , quindi tali sono anche le funzioni che

rappresentano i componenti della base ortonormale utilizzata. La (5.3.3) esprime

pertanto il prodotto scalare tra il segnale ricevuto e l’ -esimo elemento .

Le sono variabili aleatorie Gaussiane a media nulla con varianza ,

l’ortonormalità della base garantisce anche che esse sono mutuamente

statisticamente indipendenti. Osserviamo che il segnale S non contiene

nessuna informazione circa il segnale trasmesso in quanto non appartiene per

costruzione allo spazio SK dei segnali trasmessi. La nostra strategia di decisione si può

quindi basare esclusivamente su S , o, che è lo stesso, sul vettore delle sue

componenti rispetto alla base .

In sostanza il vettore costituisce la cosiddetta statistica sufficiente su cui deve

operare il ricevitore per fornire una stima del messaggio trasmesso.

Possiamo pensare il ricevitore costituito da due sistemi in cascata, un demodula-

tore che ha il compito di calcolare il vettore ed un decisore che sulla base di

quest’ultimo provvede a stimare il messaggio trasmesso.

In pratica si può pensare al vettore come alla realizzazione di un vettore di

variabili aleatorie definito sull’esperimento casuale innescato dall’emissione di un

messaggio e dal suo invio sul canale AWGN.

Cenni di Trasmissione Numerica 47

5.4 - La Regola di Decisione Ottima.

Vogliamo che la strategia seguita dal ricevitore nel suo complesso conduca alla

minima probabilità d’errore media. In altri termini vogliamo che sia minima la

probabilità di prendere decisioni sbagliate sul messaggio trasmesso, noto il segnale

ricevuto e la probabilità di emissione di ciascun messaggio.

Ovviamente la minimizzazione della probabilità d’errore equivale alla mas-

simizzazione della probabilità di corretta decisione. La regola di decisione ottima sarà

quindi quella che ci fa scegliere per il messaggio se risulta:

( ) ( ) (5.4.1)

La regola di decisione appena descritta si esprime sinteticamente scrivendo:

argma

( ) (5.4.2)

Nell’ipotesi, in questo contesto remota, in cui due o più messaggi massimizzino la

precedente sceglieremo a caso tra essi.

Quando si adotta la regola di decisione (5.4.2) si sta applicando il criterio della

massima probabilità a posteriori (MAP Maximum A posteriori Probability).

5.5 - Il Criterio della Massima Verosimiglianza.

Detto un intorno di e ( ) la sua misura possiamo scrivere:

( ) ( )

( ) (5.5.1)

indicando con ( ) la densità di probabilità di , la probabilità che vale

∫ ( )

Scegliendo opportunamente e in .possiamo ulteriormente elaborare

la (5.5.1) come segue:

( ) ( )

( )

( )

( ) ∫ ( )

∫ ( )

( )

∫ ( )

( )

( ) ( )

( )

( ) ( ) ( )

( ) ( )

( ) ( )

( )

(5.5.2)

sostituendo la (5.5.2) nella (5.4.2) otteniamo:

argma

{ ( ) ( )

( )} (5.5.3)


Appare chiaro che la densità di probabilità marginale di al denominatore della prece-

dente non ha alcuna influenza sull’argomento che lo rende massimo, pertanto possiamo

ulteriormente scrivere:

argma

( ) ( ) (5.5.4)

5.6 - Funzioni di Verosimiglianza.

Un’ulteriore semplificazione della (5.5.3), si ottiene infine se i messaggi

sono tutti equiprobabili. In questo caso, semplificando ulteriormente la notazione, po-

nendo cioè ( ) ( ), la regola di decisione ottima diventa:

decidi per se:

argma

( ) (5.6.1)

La densità di probabilità ( ) prende il nome di funzione di

verosimiglianza. Essa, come si può notare, dipende sostanzialmente dal canale, che in

questo caso pensiamo costituito dalla cascata del modulatore, del canale AWGN e del

demodulatore.

Un ricevitore che adotta la regola di decisione (5.6.1) applica il criterio della

Massima Verosimiglianza MV, o ML (Maximum Likelihood), se si preferisce

l’acronimo inglese.

È opportuno precisare che il criterio MV viene di regola adottato, anche quando

la statistica della sorgente non è nota, in questo caso il criterio non è ottimo, non

conduce cioè alla minima probabilità d’errore media, ma spesso non si può fare altri-

menti non conoscendo la statistica della sorgente, in ogni caso, in genere, la perdita in

termini di prestazioni adottando il criterio MV anziché il MAP è in genere accettabile.

5.7 - Le Regioni di Decisione.

Ricordiamo che ad ogni messaggio corrisponde tramite la (5.2.1) uno ed un

sol punto nello spazio SK. Osserviamo quindi che, se è stato trasmesso , allora

all’uscita del demodulatore sarà presente il vettore , dove

è la realizzazione di un vettore di variabili aleatorie Gaussiane a media

nulla e matrice di covarianza cioè di variabili tra loro mutuamente statisticamente

indipendenti, ne consegue che , per fissato , è anch’esso un vettore di variabili

aleatorie mutuamente indipendenti con matrice di covarianza e media .

Si ha pertanto:

m


( ) ∏

√

(

)

( )

∏

(

)

( )

∑ (

)

( )

(5.7.1)

ad ogni si può quindi associare l’insieme dei punti di SK

( ) ( ) (5.7.2)

che è denominato regione di decisione di .

Se abbiamo cura di assegnare a caso all’una o all’altra regione i punti di SK che si

trovano al confine tra due o più regioni di decisione, ci si convince facilmente che

∪

(5.7.3)

Per il canale AWGN possiamo ancora scrivere:

{ ( )

‖ ‖

( )

‖ ‖

}

{ }

(5.7.4)

dalla precedente s’intuisce facilmente che le frontiere delle regioni di decisione sono

iperpiani di SK, e che la probabilità che cada sulla frontiera di una regione di deci-

sione è in questo caso nulla, essendo nulla la misura di tali frontiere.

Il concetto di regione di decisione è applicabile anche in un contesto più ge-

nerale, basandosi direttamente sulla (5.5.3) nel caso di messaggi non equiprobabili.

Anche nel caso in cui lo spazio d’osservazione SK è discreto si possono definire

le regioni di decisione, tenendo però presente che tutte le densità di probabilità che

compaiono nelle (5.5.3) e (5.6.1) vanno intese come distribuzioni di massa di

probabilità e che in questo caso l’eventualità che il vettore cada su un punto di SK

appartenente alla frontiera di una regione di decisione può essere diversa da zero.

Indichiamo con la probabilità che il ricevitore stimi in modo errato il

messaggio sotto la condizione che sia stato trasmesso il messaggio , detto il

complementare di R rispetto allo spazio di osservazione SK, ( ) si potrà esprimere

come segue:

( ) ( ( )) (5.7.5)

La probabilità d’errore media del sistema sarà espressa dalla media statistica delle

( ). Avremo quindi:

∑ ( ) ( )

(5.7.6)


che nel caso di equiprobabilità dei messaggi trasmessi varrà:

∑ ( )

(5.7.7)

Sebbene la precedente sia concettualmente semplice, calcolarne il valore può

essere complicato. La sua valutazione comporta generalmente il calcolo d’integrali su

domini multidimensionali che difficilmente si risolvono in forma chiusa, e che anche

approcciati per via numerica possono presentare delle criticità.

È pertanto utile, in generale, e in particolare per i nostri scopi, introdurre dei

metodi che permettano di maggiorare la probabilità d’errore:

5.8 - L’Union Bound.

L’union bound è una maggiorazione della che si basa sul fatto che la

probabilità dell’unione di due eventi è minore o uguale della somma delle probabilità di

ciascuno di essi.

In particolare si osservi che se il decisore dovesse scegliere soltanto tra due

alternative, ad esempio tra il messaggio e il messaggio , vi sarebbero solo due

regioni di decisione quella R associata a e la sua complementare rispetto a SK,

R .

Ovviamente R R , risulta inoltre:

⋂

⋃

(5.8.1)

avremo pertanto:

( ∪

) ∑ ( )

(5.8.2)

Nel caso in esame:

{ } (5.8.3)

la ( ) è data da:

( )

∫ ( )

∫ ( )

∏

(

)

(5.8.4)

Al fine di calcolare la (5.8.4) è utile riformulare la disuguaglianza che definisce

la nel modo seguente:


( )

∑(

)

(5.8.5)

Osserviamo che ∑ (

)

può interpretarsi come il valore as-

sunto da una variabile aleatoria ottenuta combinando linearmente le componenti di

che, se è stato trasmesso ( ), costituiscono una -upla di variabili aleatorie Gaussiane

statisticamente indipendenti. è quindi una variabile aleatoria Gaussiana con valor

medio:

∑(

)

(5.8.6)

e varianza:

∑(

)

(5.8.7)

Ricordando che ( )

√ ∫

potremo scrivere:

( ) (

)

√

∫

( )

( )

√ ∫

(

)

(

√ ( ) ( ) )

(

√ ) (

√ )

(5.8.8)

L’ultimo membro della precedente può essere sostituito nella (5.8.2) che tenuto conto

della (5.7.6) e dell’ipotesi di equiprobabilità dei simboli trasmissibili, ci permette di

scrivere:

∑ ( ) ( )

∑ ( ) ∑ (

√ )

( )

∑ (

√ )

(5.8.9)


5.9 - Bound di Bhattacharrya.

L’union bound può essere applicato anche al caso in cui lo spazio di osservazione

sia discreto. Consideriamo ad esempio il caso di una sorgente binaria priva di memoria

che emetta una parola di bit, vogliamo trasmettere la parola in questione utilizzando

un BSC volte con . Il compito del codificatore di canale consiste quindi

nell’associare a ciascuno dei possibili messaggi di sorgente una tra le possibili

parole da affidare al canale. Chiameremo codice il sottoinsieme delle parole scelte.

Osserviamo che per effetto del canale la parola ricevuta potrebbe non appartenere

al codice, ma in ogni caso sarebbe una tra le . In sostanza lo spazio d’osservazione

è in questo caso finito.

La probabilità ( ) che venga rivelata la parola quando è stata trasmessa la

parola di codice è data da

( ) ( ) ( ) (

) (5.9.1)

in cui rappresenta il numero di simboli in cui differisce da e la probabilità di

crossover del BSC. Osserviamo che, se

,

, ( ) è quindi una funzione

decrescente di che, come vedremo in seguito, è detta distanza di Hamming. Ciò ci

permette di associare a ogni parola di codice una regione di decisione, che conterrà i

punti dello spazio d’osservazione, cioè le parole di bit aventi da essa una distanza

minore rispetto a quella che hanno dalle altre parole di codice, convenendo di assegnare

in modo puramente casuale a una sola delle regioni interessate i punti dello spazio

d’osservazione che dovessero trovarsi a uguale distanza da due o più parole di codice.

Ciò premesso, il calcolo della probabilità d’errore condizionata all’emissione di

una data parola di codice vale:

∑ ( )

(5.9.2)

e la probabilità d’errore media:

∑ ( ) ∑ ( )

(5.9.3)

dove ( ) rappresenta la probabilità di emissione della parola da parte del

codificatore di canale, che equivale, essendo il codificatore deterministico, a quella di

emissione della corrispondente parola di bit dalla sorgente.

Anche in questo contesto è possibile applicare lo union bound. Individuando le

associate alle coppie di parole di codice possiamo infatti scrivere:


( ) ∑ ( )

(5.9.4)

tramite la funzione ausiliaria

( ) {

(5.9.5)

possiamo riformulare la (5.9.4) come segue

( ) ∑ ( ) ( )

S

(5.9.6)

Osserviamo che S risulta:

( ) ( ( )

( ))

(5.9.7)

possiamo pertanto maggiorare la (5.9.6) ottenendo:

( ) ∑( ( )

( ))

( )

S

∑( ( )) ( ))

S

∑[∏( (

) (

))

]

S

∏ ∑ ( (

) (

))

(5.9.8)

in cui abbiamo anche tenuto conto del fatto che il canale è privo di memoria.

La sommatoria a ultimo membro della precedente può assumere solo due valori a

seconda che

risulti o meno uguale a

nel primo caso la somma varrà nell’altro

√ ( ). Potremo finalmente scrivere:

( ) ∏ ∑ ( (

) (

))

( √ ( ))

(5.9.9)

essendo la distanza di Hamming tra e .

Quella appena ottenuta è la maggiorazione di Bhattacharyya. Che tramite l’union

bound ci permette di scrivere:

∑ ( ) ∑( √ ( ))

(5.9.10)

Il bound di Bhattacharyya sulla probabilità d’errore può essere applicato anche

nel caso di spazio d’osservazione continuo.


Per mostrarlo prendiamo nuovamente in considerazione la (5.8.4), possiamo scrivere:

( | ) ∫ ( | )

∫ √ ( )

( ) ( | )

S

∫ √ ( ) ( ) S

(5.9.11)

la quale sostituendo alle ddp condizionate che vi compaiono le loro espressioni

fornisce:

( | )

∫ √ ( ) ( ) S

( )

∫

∑ (

) (

)

S

( )

∫

∑ (

)

S

∏ ∫

√

(

)

)

∏ ∫

√

(

)

(

)

∏

(

)

∏

∑ (

)

(5.9.12)

La precedente può essere utilizzata nell’union bound

∑ ( ) ( )

∑ (

√ )

∑

‖ ‖

(5.9.13)

La (5.9.13), a ben vedere, si poteva ottenere direttamente utilizzando una ben

nota catena di disuguaglianze relative alla ( ), risulta infatti (vedi Fig.E 5.1):

√ (

)

( )

√

( )

(5.9.14)


Constatiamo che, nel caso di

spazio di osservazione continuo, la

maggiorazione di Bhattacharyya sep-

pur asintoticamente stretta è comun-

que più “lasca” di quelle che si pos-

sono ottenere maggiorando la ( )

tramite una delle precedenti. Utiliz-

zando ad esempio la seconda si intro-

durrebbe un fattore

vale cioè la se-

guente disuguaglianza:

∑

‖ ‖

(5.9.15)

L’utilizzo della prima delle (5.9.14) fornirebbe come risulta evidente dalla Fig.E

5.1Fig.E 5.1 una maggiorazione certamente più stretta solo qualora i valori degli

argomenti delle ( ) nella (5.9.13) fossero tutti maggiori di √

.

5.10 - Bound di Gallager.

Lo Union Bound può rivelarsi in molti casi una maggiorazione piuttosto lasca,

talvolta addirittura palesemente inutile se dovesse risultare maggiore di uno.

Un diverso approccio per maggiorare è quello di considerare una regione

e valutare la probabilità ( ) . Quest’ultima, sarà

necessariamente non minore di . A tale scopo consideriamo il seguente sotto-

insieme dello spazio d’osservazione SK:

{ ∑ ( ( )

( ))

} (5.10.1)

dove è un reale positivo scelto ad arbitrio. , infatti, si osservi che la

sommatoria nella (5.10.1) è a termini positivi, inoltre se allora per definizione

esiste almeno un tale che ( ) ( ), ciò, essendo , comporta

che almeno un addendo, e quindi tutta la sommatoria, assuma un valore maggiore di

in ogni punto di . Introducendo la funzione ausiliaria:

( ) {

(5.10.2)

possiamo scrivere:

Fig.E 5.1 - 𝑄(𝑥), 𝟏

𝟐𝒆𝒙𝟐

𝟐 , 𝟏

√𝟐𝝅𝒙𝟐𝒆

𝒙𝟐

𝟐


( ) ∫ ( )

∫ ( ) ( )

S

(5.10.3)

È inoltre facile verificare che per ogni reale positivo risulta:

( ) [∑ ( ( )

( ))

]

(5.10.4)

la (5.10.3) può quindi essere ulteriormente maggiorata ottenendo:

( ) ∫[∑ ( ( )

( ))

]

( )

S

∫[∑( ( ))

]

( )

S

(5.10.5)

La precedente può essere semplificata se si pone

otteniamo infatti:

( ) ∫ [∑( ( ))

]

( )

S

(5.10.6)

La maggiorazione della probabilità d’errore che si ottiene dalla (5.10.6), me-

diando sui messaggi , è applicabile anche a spazi d’osservazione discreti, a patto di

sostituire l’integrale con una sommatoria estesa all’intero spazio d’osservazione e di

interpretare le densità di probabilità che vi compaiono come distribuzioni di massa di

probabilità:

( ) ∑ [∑( ( ))

]

( )

S

(5.10.7)

L’utilizzo del bound di Gallager in pratica rimane ristretto ad un limitato insieme

di sistemi di trasmissione in quanto esso comporta comunque il calcolo di integrali o

sommatorie multidimensionali che rapidamente diventano impraticabili. Va anche

sottolineato il fatto che il valore di al secondo membro delle (5.10.6) e (5.10.7) deve

essere ottimizzato se si vuole rendere la maggiorazione più stretta possibile. In questo

contesto il bound appena introdotto è propedeutico alla dimostrazione del teorema di

Shannon sulla codifica di canale che verrà dimostrato nel prossimo capitolo.

Capitolo - 6

IL TEOREMA DI SHANNON SULLA CODIFICA DI CANALE

6.1 - Premessa.

Shannon, nel suo pionieristico lavoro del 1948, individuò una maggiorazione

della probabilità d’errore che, anziché cercare di maggiorare la probabilità d’errore

associata alla scelta di uno specifico insieme di segnali si propone di maggiorare la

probabilità di errore media tra tutti i possibili set costituiti da un numero fissato di

segnali contenuti in un sottospazio di dimensione assegnata , nell’ipotesi in cui tutte

le componenti di oguno di essi possano assumere valori appartenenti al medesimo

alfabeto di cardinalità finita . Sotto queste ipotesi si possono effettuare un numero

finito di scelte per la -upla di segnali da impiegare, esistono infatti solo ( )

possibili -uple di segnali, alcune delle quali in realtà non “felici” in quanto utilizzano

più volte uno stesso segnale.

Shannon sfruttò il fatto che una qualsiasi funzione di variabile aleatoria può

certamente assumere un valore non maggiore del suo valor medio. Applicato al caso in

esame ciò comporta l’esistenza di almeno una -upla di segnali che da luogo ad una

probabilità d’errore non maggiore della media tra le probabilità di errore di tutte le -

uple.

È interessante osservare che quest’affermazione resta valida quale che sia la

distribuzione di massa di probabilità che si sceglie per calcolare la media citata, nel

caso particolare potremmo ad esempio scegliere la media aritmetica, daremmo in

questo caso uguale peso a ogni possibile -upla, ovvero potremmo attribuire pesi

diversi ad esempio associando peso nullo a tutte le -uple in cui uno stesso segnale è

utilizzato più di una volta, in questo caso evidentemente il valor medio tra le probabilità

di errore sarebbe verosimilmente una maggiorazione più stretta, altre scelte potrebbero

rivelarsi infelici, ma costituirebbero comunque una maggiorazione per la probabilità

d’errore di almeno una - upla.

6.2 - La Disuguaglianza di Jensen

Nel precedente paragrafo è stata utilizzata una disuguaglianza che risulta utile

anche nella trattazione di altri argomenti legati alla Teoria dell’Informazione.

Cominciamo con il definire un sottoinsieme convesso di uno spazio vettoriale:


Definizione 6.1

Un sottoinsieme di uno spazio vettoriale su o su è convesso se comunque presi

due suoi elementi e un reale non negativo non maggiore di risulta:

( ) A (6.2.1)

***********

La precedente in sostanza ci dice che insieme è convesso se contiene tutte le

corde che uniscono coppie di suoi elementi. Un esempio di regione convessa in è

l’insieme di tutte le possibili distribuzioni di massa di probabilità di una variabile

aleatoria discreta che assume valori appartenenti ad un

insieme di cardinalità . Ad esempio in tale

regione è costituita dal segmento della retta

appartenente al primo quadrante. Nel caso di (vedi

Fig.E 6.1) da tutti i punti del piano di

coordinate non negative.

È facile convincersi del fatto che:

- l’intersezione (anche infinita) d’insiemi convessi

e convessa

- l’insieme ottenuto moltiplicando tutti gli elementi di un convesso per uno scalare è

convesso.

- è convesso l’insieme che ha per elementi tutte le possibili somme tra elementi

appartenenti a due insiemi convessi.

Definizione 6.2

Una funzione ( ) a valori in si dice concava su un sottoinsieme convesso del

suo dominio se comunque presi due elementi appartenenti ad e un reale non

negativo risulta:

( ) ( ) ( ) ( ( ) ) (6.2.2)

Se risulta

( ) ( ) ( ) ( ( ) ) (6.2.3)

la funzione si dice strettamente concava

***********

La definizione di funzione convessa è uguale alla precedente salvo il fatto che le

diseguaglianze cambiano di verso.

A

1 2,x x

Fig.E 6.1

Il Teorema di Shannon sulla Codifica di Canale 59

Nel caso di funzioni definite su sottoinsiemi di la precedente caratterizza le

funzioni con concavità rivolta verso il basso in tutti i punti di un intervallo che è un

sottoinsieme convesso di , è noto che laddove esiste la derivata seconda di una

funzione concava è non positiva.

Osserviamo che la combinazione lineare di funzioni concave è concava lo è

strettamente se anche una sola delle funzioni lo è. Per verificarlo è sufficiente sommare

termine a termine le (6.2.2) scritte per ciascuno degli addendi della combinazione

lineare.

Osservando la (6.2.2) notiamo che se si interpretano ed come i valori che

può assumere una V.A. generalmente multidimensionali e con ed

rispettivamente le probabilità che essa li assuma, potremo affermare che per una

funzione concava su un convesso che contenga tutti i valori che la V.A. può assumere

ed una V.A. del tipo citato vale la proprietà:

( ) ( ) (6.2.4)

Vogliamo mostrare che la precedente è valida in generale cioè per variabili aleatorie

discrete generalmente multidimensionali che possano assumere valori.

Abbiamo mostrato che la (6.2.4) è vera per , per lo è banalmente

supponiamo quindi che lo sia per e mostriamo che allora lo è anche per .

Se la (6.2.4) è vera per quale che sia la dmp di si ha:

∑ ( )

(∑( )

) (6.2.5)

dove rappresenta la probabilità che la variabile aleatoria assuma il valore .

Risulta:

∑ ( )

∑

(∑

∑

( )

) ( ) (6.2.6)

Osserviamo che ∑

∑

soddisfa tutte le proprietà di una dmp quindi in virtù

della (6.2.5) possiamo scrivere:

∑ ( )

∑

( (∑

∑

)) ( )

∑

( ( )) ( )

(6.2.7)

dove è certamente un punto appartenente al convesso su cui è definita la funzione.

1n X


All’ultimo membro della precedente potremo applicare la (6.2.2) ottenendo:

∑ ( )

∑

( ( )) ( ) (∑

)

(∑ ∑

∑

) (∑

) ( )

(6.2.8)

ovviamente la (6.2.5) diventa

∑ ( )

(∑( )

) (6.2.9)

se la ( ) anziché essere concava è convessa.

6.3 - Il Teorema di Shannon sulla Codifica di Canale.

Consideriamo la probabilità d’errore condizionata all’emissione dell’ -esimo

segnale di una data -upla, essa è in realtà una funzione della -upla nel suo complesso,

in quanto il cambiamento anche di un solo segnale nella -upla può comportare la

modifica della regione di decisione associata ad , per sottolineare ciò, porremo in

quel che segue ( ).

Dovendo calcolare la media sopra citata, e tenuto conto delle considerazioni fatte

in merito, possiamo scegliere ad arbitrio una distribuzione di massa di probabilità

( ) per le -uple di possibili segnali. Per semplicità suppo-

niamo che

( ) ∏ ( )

(6.3.1)

e che tutte le d.m.p. marginali che compaiono nella produttoria siano identiche.

Avremo quindi:

∑ ∑ ∑ ∏ ( ) (

)

(6.3.2)

utilizzando il bound di Gallager otteniamo:

∑ ∑ ∑ ∏ ( )

∫ [ ∑ ( ( ))

]

( )

S

(6.3.3)

che può essere riscritta sfruttando il teorema della media (portando cioè la media

all’interno dell’integrale) come segue:

∫ ∑ ( ) ( )

{∑ ∑ ∑ ∑ ∏ ( ) [ ∑ ( ( [ ]))

]

}

S

(6.3.4)


Osserviamo che ∑ ( ( ))

, può intendersi come il valore

assunto da una variabile aleatoria reale . Nel derivare il bound di Gallager avevamo

supposto se adesso lo limitiamo all’intervallo , è una funzione concava

di (concavità rivolta verso il basso), quindi possiamo applicare la disuguaglianza di

Jensen (vedi § precedente) che garantisce che il valor medio di una funzione concava di

una V.A. è non maggiore del valore che detta funzione assume in corrispondenza al

valor medio della V.A..

Sulla base di quanto appena detto possiamo maggiorare il contenuto delle pa-

rentesi graffe della precedente come segue:

∑ ∑ ∑ ∑ ∏ ( ) [ ∑ ( ( ))

]

( )

[∑ ∑ ∑ ∑ ∏ ( ) ∑ ( ( ))

]

[ ∑ ∑ ∑ ∑ ∑ ∏ ( ) ( ( ))

]

[ ∑ ∑ ( ) ( ( ))

]

[( ) ∑ ( ) ( ( ))

]

(6.3.5)

L’ultimo membro della precedente ci consente di maggiorare ulteriormente la

ottenendo:

∫ ∑ ( ) ( ( ))

[( )∑ ( )( ( ))

]

S

( ) ∫ [∑ ( )( ( ))

]

S

∫ [∑ ( )( ( ))

]

S

(6.3.6)

Ulteriori elaborazioni della precedente si possono ottenere osservando che il

contenuto delle parentesi quadre all’ultimo membro di essa può intendersi come il valor

medio della ( ( ))

pensata come funzione della V.A. multidimensionale . Ciò

premesso, se introduciamo l’ipotesi ( ) ∏ ( )

, cioè che il canale, se

utilizzato in tempi diversi per inviare le componenti del segnale , sia privo di

memoria, ovvero che per inviarle si utilizzino contemporaneamente canali identici


indipendenti tra loro, sostituendo nella (6.3.6) e ricordando che la media di un prodotto

è uguale al prodotto delle medie otteniamo:

∫ [ ∑ ∑ ∑ (

)∏ ( ( | ))

]

S

∫ [∏ ∑ (

) ( ( | ))

]

S

(6.3.7)

la quale limitandoci a considerare delle ( ) ∏ ( )

fornisce ancora:

∫[∏ ∑ ( ) ( (

))

]

S

∫∏[∑ ( )( ( ))

]

S

{∫ [∑ ( )( ( ))

]

}

(6.3.8)

È opportuno ribadire che la maggiorazione ricavata è del tutto generale, essendo

basata sul bound di Gallager, quindi si applica anche a canali discreti.

Pertanto, prima di procedere oltre, provvediamo a riscrivere la (6.3.8) per spazi

d’uscita discreti. Per farlo dobbiamo sostituire l’integrale con una sommatoria estesa a

tutti i possibili simboli dell’alfabeto d’uscita che supporremo di cardinalità , e la

densità di probabilità condizionata che caratterizza il canale con uscita nel continuo con

le dmp condizionate del DMC ottenendo:

[∑(∑ ( )( ( ))

)

]

(6.3.9)

è utile riscrivere la precedente nella forma:

{ [∑ (∑ ( )( ( ))

)

]

}

{ [∑ (∑ ( )( ( ))

)

]}

{

[∑ (∑ ( )( ( ))

)

]}

(6.3.10)

che ne rende esplicita la dipendenza dal rapporto

.

Ricordiamo che è il numero di segnali utilizzati e la dimensione del sotto-

spazio in cui detti segnali sono contenuti, si può interpretate come la massima

quantità d’informazione, espressa in nat, che i parametri fissati per il sistema consenti-

rebbero di affidare a ogni dimensione del sottospazio. rappresenta quindi il data rate.


La (6.3.10) si può esprimere in forma più compatta ponendo:

( ( )) [∑(∑ ( )( ( )

)

)

] (6.3.11)

Sostituendo la precedente nella (6.3.10) otteniamo:

( ( ( )) ) (6.3.12)

Il minimo al variare di e ( ) del secondo membro della precedente fornisce la

maggiorazione più stretta. La minimizzazione citata equivale alla ricerca di:

( )

( ( )) ( ) (6.3.13)

Ovviamente tale ricerca deve tener conto delle limitazioni poste su , che deve

appartenere all’intervallo e del fatto che la ( ) deve soddisfare le proprietà di

una dmp che assume valori in un insieme di cardinalità .

Osserviamo infine che la maggiorazione appena ricavata non dipende da

quindi essa è anche una maggiorazione per la probabilità d’errore media del sistema.

Tutto ciò considerato possiamo scrivere:

( ) (6.3.14)

Appare chiaro quanto siano importanti le proprietà della ( ( )).

In quel che segue per semplificare la notazione porremo ( ) , ( ) ,

indicheremo la distribuzione di massa ( ) con

Possiamo osservare che, indipendentemente dalla ( ), risulta:

( ) [∑(∑ ( )

)

] [∑ ∑

] (6.3.15)

si ha inoltre:


( )

|

{ [∑ (∑ ( )

)

]}

||

∑ (∑ ( )

)

||

∑ [∑ ( )

]

||

∑

{( ) [∑ ( )

]}

|

|

∑

{

(∑ )

)

{

[∑ ( )

]

( )∑ ( )

( )

( )

∑ ( )

|

}

}

∑

(

( )

∑ ( )

)

∑ ( )

∑∑ ( ) ∑∑

( ) I( )

(6.3.16)

La precedente in sostanza dice che la pendenza della ( ), valutata per

e pensata come funzione della sola , è pari all’informazione mutua del canale

connesso ad una sorgente che emette simboli distribuiti secondo la . Per questo

motivo abbiamo indicato la suddetta informazione mutua come una ( ) che evidenzia

la dipendenza dalla distribuzione sotto il nostro controllo.

Abbiamo già visto che ( ) . Se risulta ( ) allora la ( ) che,

come abbiamo visto attraversa l’asse delle nell’origine, assume certamente valori

positivi in un intorno destro di quest’ultima.

Si può anche verificare che la ( ), se ( ) , è una funzione strettamente

crescente e che la sua derivata seconda è non positiva per . Essa ha quindi la

concavità rivolta verso il basso, salvo alcune eccezioni in cui la derivata seconda è

nulla, ma tali casi non hanno interesse pratico.

Il nostro scopo è quello di massimizzare la ( ) , consideriamo per il

momento solo la dipendenza da , la derivata parziale rispetto a della funzione in

parola vale:

( )

(6.3.17)


affinché si annulli deve risultare ( )

. Sappiamo che

( )

non è crescente

poiché sua derivata è non positiva, pertanto la (6.3.17) non può annullarsi per

se:

( )

|

(6.3.18)

Ovvero se

( )

|

( ) (6.3.19)

per i valori di che soddisfano la (6.3.18) risulta, ( )

quindi ( )

è strettamente crescente nell’intervallo ed assume il suo massimo valore

nell’estremo destro dell’intervallo; avremo cioè:

( ) ( ) ( )

|

(6.3.20)

per

( )

|

( ) (6.3.21)

la (6.3.17) si annulla certamente per un valore di appartenente all’intervallo che

risolve l’equazione ( )

. Tale zero corrisponde certamente a un massimo come

si constata facilmente analizzando il segno della (6.3.17). La ( ) nel range di valori

di dato dalla (6.3.21) è implicitamente definita dalle:

{

( ) ( )

( )

( )

(6.3.22)

dalle quali si ottiene:

( )

( ( ) ( )

)

( )

( )

( )

( )

(6.3.23)

che comporta:

( )

( ( )

)

( )

(6.3.24)


Nelle ultime due equazioni il secondo membro è una funzione di essendo la

soluzione della seconda delle (6.3.22) che è unica in quanto nell’intervallo di interesse

abbiamo visto che la ( )

è una funzione strettamente crescente di .

Per i valori di ( ) la (6.3.17) assumerebbe valori negativi quindi la

( ) sarebbe una funzione decrescente di quindi il suo massimo lo

raggiungerebbe per , ma ( ) indipendentemente da ne seguirebbe

( ) e la (6.3.14) si rivelerebbe del tutto inutile.

In conclusione la ( ) per valori di appartenenti all’intervallo

[ ( )

|

] è un tratto di retta parallela alla seconda bisettrice che tocca l’asse

delle ordinate in ( ( )) alla quale si raccorda un tratto di curva con

concavità rivolta verso l’alto che tocca l’asse delle ascisse in I( ), come si verifica

facilmente valutando le (6.3.22) per . A questo punto non resta che massimizzare

la ( ( )) rispetto alla ( ).

La che massimizza la ( ) dipende dal canale che si sta utilizzando, e, per

fissato canale può dipendere dal rate , in particolare esistono canali per cui la ( )

è massimizzata da un'unica , canali per i quali esistono delle distinte che

massimizzano la funzione in parola in intervalli di disgiunti e canali per cui la ( )

che massimizza la ( ) varia con continuità con . In ogni caso il fatto che la

( ) sia una funzione limitata convessa per I( ) , assicura che la

massimizzazione desiderata è in pratica l’inviluppo superiore di tutte le ( ), si può

dimostrare che detta funzione è anch’essa convessa, decrescente e non negativa per

, dove

I( ) è la capacità di canale e che in questo contesto assume

un ruolo fondamentale.

In sostanza abbiamo appena dimostrato il Teorema di Shannon sulla codifica di

canale, che possiamo recitare come segue:

Teorema 6.1

Dato un qualsiasi canale discreto privo di memoria, esiste sempre un codice con un

rate [

], le cui parole sono costituite da simboli per il quale risulta:

( ) (6.3.25)

dove è la probabilità d’errore ottenuta tramite un ricevitore a massima

verosimiglianza ed ( ) una funzione decrescente, convessa e maggiore di zero

nell’intervallo .


***********

Il precedente teorema in pratica mostra che se aumentiamo mantenendo

costante possiamo individuare codici con probabilità d’errore piccola a piacere purché

risulti . È opportuno tuttavia osservare che al crescere di il numero di parole di

codice necessario per mantenere costante il rate cresce anch’esso, “purtroppo” con

legge esponenziale, aumentando così, spesso a livelli improponibili, la complessità di

decodifica. Da qui la necessità di individuare codici su spazi dotati di strutture

algebriche molto ricche che permettano operazioni di codifica e decodifica semplici,

malgrado l’elevato numero di parole che li costituiscono.

Potrebbe sorgere una perplessità circa il risultato appena ottenuto, si potrebbe

infatti sospettare che il bound ottenuto per la probabilità d’errore media del codice

nasconda delle probabilità d’errore condizionate all’emissione di una specifica parola

del codice molto maggiore del bound relativo alla probabilità d’errore media.

Per fugare questa legittima perplessità consideriamo uno spazio di dimensione ,

o che è lo stesso un codice costituito da parole di simboli emessi consecutivamente

da un codificatore di canale. Il teorema di Shannon ci garantisce che esiste almeno un

set di parole tra le possibili scelte, che esibisce una probabilità d’errore

media non maggiore di:

( ( )

) (6.3.26)

Se assumiamo che le parole che costituiscono il codice abbiano uguale probabilità di

essere emesse, allora avremo:

∑

(6.3.27)

Scartando gli M segnali cui corrispondono le probabilità d’errore più grandi, ci

rendiamo conto che la probabilità d’errore associata ad uno qualsiasi dei segnali

sopravvissuti non può essere maggiore di ( ( )

). Se così non fosse, almeno ad

un termine dei sopravvissuti corrisponderebbe una ( ( )

) vi sarebbero

quindi almeno segnali, quelli scartati più quello appena citato, con

( ( )

) e potremmo scrivere:

( ) (

( )

)

(

( )

) (

( )

)

(6.3.28)

contro l’ipotesi che il codice soddisfa la (6.3.26).

Per ogni del gruppo dei sopravvissuti potremo allora scrivere:


( ( )

)

(

( ( ) ( )

))

( ( )

( ( )

))

(

( ( )

( )

))

(

( )

)

(6.3.29)

Abbiamo appena mostrato che esiste certamente un codice per il quale la peggiore delle

probabilità d’errore condizionata supera il bound sulla probabilità d’errore media per al

più un fattore .

Capitolo - 7

STRUTTURE ALGEBRICHE

Al fine di introdurre il concetto di codice è opportuno ricordare alcune

definizioni:

7.1 - Gruppo

Un insieme non vuoto in cui si è definita una legge di composizione interna che

indicheremo con è un gruppo rispetto a tale legge se valgono le seguenti proprietà:

( ) ( )

(7.1.1)

Se la legge di composizione interna è anche commutativa è un gruppo

commutativo o abeliano.

7.2 - Anello

Un insieme nel quale siano state individuate due leggi di composizione interna

che chiameremo addizione e moltiplicazione è un anello se:

- è un gruppo commutativo rispetto all’addizione;

- la moltiplicazione gode della proprietà associativa;

- vale la legge distributiva della moltiplicazione rispetto all’addizione sia a destra che

a sinistra.

Se la moltiplicazione gode anche della proprietà commutativa diremo che è un

anello commutativo, se esiste in l’elemento neutro per la moltiplicazione diremo che

è un anello con identità.

7.3 - Campo

Un insieme che sia un anello commutativo con identità è anche un campo se

privato dell’elemento neutro rispetto all’addizione è un gruppo commutativo rispetto

alla moltiplicazione.

L’insieme dei numeri razionali, l’insieme dei reali e l’insieme dei

complessi sono campi. Si verifica facilmente che anche l’insieme , effettuando

l’addizione senza riporto, cioè ponendo e con la usuale moltiplicazione in

è un campo che indicheremo con .

7.4 - Spazio vettoriale

Dato un gruppo abeliano ed un campo si dice che è uno spazio vettoriale

sul campo se si è individuata una legge di composizione esterna, detta prodotto per


scalari, che associa ad ogni elemento di un elemento di e che comunque scelti

e goda delle proprietà:

( )

( )

(7.4.1)

dove e indicano rispettivamente gli elementi neutri dell’addizione e della

moltiplicazione del campo, quello del gruppo, che chiameremo anche origine dello

spazio.

Capitolo - 8

8.1 - Lo Spazio

Fissato un naturale consideriamo l’insieme di tutte le -uple ordinate

d’elementi di . Ci si rende conto facilmente che è un gruppo rispetto alla legge di

composizione interna che associa ad ogni coppia di elementi di quello ottenuto

componendo termine a termine tramite l’addizione in gli elementi omologhi delle

due -uple. Si constata che ogni -upla è l’opposta di se stessa e che l’elemento

neutro del gruppo è la -upla identicamente nulla.

è anche uno spazio vettoriale di dimensione sopra il campo , potremo

quindi pensare gli elementi di come vettori riga con componenti che assumono

valori in . In quel che segue indicheremo gli elementi di con lettere corsive

minuscole in grassetto e li chiameremo parole di , o semplicemente parole, le

componenti della generica parola saranno chiamate bit (nel senso di Binary digIT, non

di Binary Informationn uniT).

È opportuno tenere presente che:

- è uno spazio metrico, possiamo infatti assumere come distanza tra due parole di

la somma in delle somme in delle componenti omologhe;

- è uno spazio normato potendosi assumere come norma del generico elemento di

la distanza di detto elemento dall’origine di , cioè dalla parola identicamente

nulla.

In quel che segue indicheremo l’addizione nel campo con .

La distanza sopra introdotta è detta distanza di Hamming. Essa in pratica è

espressa dal numero di bit corrispondenti diversi delle due parole; in formule:

( ) ∑

(8.1.1)

Che la distanza di Hamming sia effettivamente una metrica si verifica facilmente,

essa è non negativa ed è nulla se e solo se le parole sono uguali, inoltre si può

facilmente verificare che vale la disuguaglianza triangolare, cioè che date tre parole

di risulta:

( ) ( ) ( ) (8.1.2)

per sincerarsene basta esplicitare la precedente:

∑

∑

∑

(8.1.3)


ed osservare che tutti gli addendi delle sommatorie che compaiono nella precedente

sono non negativi, pertanto è sufficiente verificare che la (8.1.3) sia soddisfatta

addendo per addendo, fatto questo facilmente verificabile effettuando delle prove

esaustive.

La massima distanza possibile tra due parole di vale e si ottiene in

corrispondenza a coppie di parole che siano una la negata dell’altra, cioè ottenute

mutando tutti i bit uno in zero e viceversa.

La norma di un elemento di viene denominato peso della parola e coincide

con il numero di bit uno presenti nella parola.

La norma e la metrica appena introdotte sono tra loro coerenti, infatti la distanza

tra due elementi coincide con la norma della differenza tra di essi. Ricordiamo che in

addizione e sottrazione coincidono, in quanto ogni elemento è l’opposto di se

stesso.

8.2 - Generalizzazione della distanza di Hamming

Dato un insieme di cardinalità consideriamo l’insieme A . Anche su detto

insieme si può introdurre la distanza di Hamming tra due suoi elementi, che anche in

questo caso è espressa dal numero di simboli corrispondenti diversi tra loro. La

distanza tra due elementi di A è quindi al più .

Si può verificare che la distanza di Hamming è una metrica su A . Essa è non

negativa, nulla se e solo se i due elementi sono lo stesso elemento, la verifica della

validità della disuguaglianza triangolare può essere effettuata analizzando tutti i casi

possibili.

Fissato un elemento di A ed un naturale esistono ( )( ) elementi

di A a distanza da . Potremmo dire che detti elementi giacciono sulla superficie di

una sfera di raggio centrata in . La sfera appena citata contiene esattamente

∑ ( )( )

elementi. Il numero di tali elementi, per analogia, costituisce il “vo-

lume” di detta sfera.

Qualora A fosse anche uno spazio vettoriale, tramite la distanza di Hamming si

potrebbe individuare un “peso” per ogni elemento di A espresso dalla distanza

dell’elemento dall’origine dello spazio, tale peso costituirebbe una possibile norma per

A .

Capitolo - 9

CODICI BINARI A BLOCCHI

9.1 - Codificatore, Codice, Decodificatore

Cominciamo con alcune definizioni:

Definizione 9.1 - codificatore a blocchi

Un codificatore binario a blocchi è un’applicazione da a , se è iniettiva il

codificatore è non ambiguo.

***********

Definizione 9.2 - codice binario a blocchi

Dato un codificatore da a chiameremo codice binario a blocchi l’insieme

( ) . Gli elementi di sono denominati parole di codice.

***********

In altri termini per codice binario a blocchi intenderemo l’insieme delle parole di

che sono immagine secondo il codificatore di almeno un elemento di , uno

solo se il codificatore è non ambiguo.

In questo contesto la finalità di un codice è quella di combattere l’effetto dei

disturbi introdotti dal canale nel segnale ricevuto, tali disturbi potrebbero infatti dar

luogo ad errori nella ricezione. Compito del sistema di codifica è ridurre la frequenza di

tali errori seguendo una delle seguenti strategie:

- individuare e segnalare gli errori che si verificano con maggiore probabilità; ciò è

utile qualora sia disponibile un canale di ritorno, non sia necessario trasmettere in

tempo reale e sia quindi possibile la ritrasmissione del messaggio senza

pregiudicare la qualità del servizio, In questo caso si parla di tecniche di tipo ARQ

(Automatic Repeat-reQuest);

- tentare , qualora la ritrasmissione non sia possibile, di correggere gli errori che più

verosimilmente sono presenti nella parola ricevuta in questo caso si fa riferimento a

strategie di tipo FEC (Forward Error Correction).

In alcuni casi sono previste entrambe le strategie, cioè alcuni errori vengono rivelati e

corretti, altri semplicemente segnalati.

In quel che segue ci occuperemo principalmente di sistemi di codifica finalizzati alla

FEC. La funzione di correzione sopra citata è affidata a un’applicazione D che

chiameremo decodificatore.


Definizione 9.3 - decodificatore

Dato un codice binario a blocchi , il decodificatore è un’applicazione

che sulla base di un criterio prefissato, ha il compito di associare ad ogni elemento di

che si presenti all’uscita del canale l’elemento di che verosimilmente era stato

immesso nel codificatore posto all’ingresso del canale stesso.

***********

Quanto appena detto rende chiaro che più che di codici bisognerebbe parlare di

sistemi di codifica-decodifica, sia perché uno stesso codice (in quanto sottoinsieme

di ) potrebbe essere ottenuto con codificatori diversi, sia perché potrebbe essere

decodificato con decodificatori basati su criteri diversi.

Nella pratica in effetti quando si parla di codice ci si riferisce indifferentemente,

capiterà anche noi, sia a che a , lasciando al contesto l’onere di rendere chiaro al

lettore a cosa si stia effettivamente facendo riferimento.

Appare in conclusione chiaro che un sistema di codifica è in realtà comple-

tamente definito solo dalla terna .

La capacità di correzione di un codice è in pratica affidata alla ridondanza più o

meno oculatamente introdotta dal codificatore, ne discende che di regola e che il

codificatore è un’applicazione iniettiva.

Altrettanto evidente è che, se il codice è non ambiguo, il criterio adottato per la

scelta del decodificatore deve necessariamente essere tale che la restrizione di a

coincida con l’applicazione inversa della restrizione di a .

9.2 - Utilità della codifica di canale

La scelta del codice, e quella del decodificatore possono avere un considerevole

impatto sulle prestazioni del sistema di trasmissione in termini di probabilità d’errore e

di complessità del sistema.

Va anche sottolineato che, per fissato codice, possono essere individuati diversi

decodificatori. Per taluni sistemi può essere più qualificante ottimizzare la probabilità

d’errore sul singolo bit informativo, per altri quella sul simbolo trasmesso, nella scelta

del decodificatore se ne dovrebbe tener conto. Un altro elemento da considerare nella

scelta del sistema di codifica è il tipo di canale, che può essere il classico AWGN, un

canale dotato di memoria, con conseguente presenza d’interferenza intersimbolica, o un

canale che introduce disturbi di tipo burst, cioè disturbi che seppur di breve durata

tendono a coinvolgere più simboli consecutivi.

Codici Binari a Blocchi 75

Non si può nemmeno trascurare tra i parametri da tenere in considerazione la

complessità della decodifica. Scegliere ad esempio un algoritmo di decodifica sub-

ottimo, comporta in genere un degrado delle prestazioni, detto degrado, però, potrebbe

essere ampiamente ripagato da una significativa riduzione della complessità e quindi

dei costi, ovvero potrebbe essere una scelta obbligata da limiti tecnologici contingenti.

In particolare per il momento faremo riferimento a un sistema che trasmette su un

BSC (Binary Symmetric Channel) privo di memoria. I simboli che costituiscono la

generica parola di codice vengono quindi inviati indipendentemente sul canale e

ciascuno di essi avrà una probabilità

di essere rivelato in modo errato, pertanto in

uscita al canale avremo un elemento di che non è certo corrisponda all’elemento

inviato.

La probabilità di ricevere una parola di correttamente sarà data da (

) ad esempio con e avremo conseguentemente la

probabilità di ricevere una parola non corretta vale , tale probabilità è in

realtà scomponibile nella somma di tante probabilità d’eventi disgiunti, precisamente

eventi del tipo: “nella parola ricevuta sono presenti esattamente errori”.

La probabilità che la parola ricevuta non sia corretta si può quindi anche scrivere nella

forma:

∑( ) ( )

(9.2.1)

dove il - esimo addendo esprime la probabilità che nella parola ricevuta siano presenti

esattamente t errori. La probabilità che la parola contenga almeno due errori si può

pertanto scrivere anche nella forma:

∑( ) ( )

(9.2.2)

nel nostro esempio tale probabilità si ridurrebbe a .

Quanto detto mostra come il contributo alla probabilità dell’errore singolo sia di

fatto dominante essendo gli addendi della (9.2.1) rapidamente decrescenti al crescere di

1.

Disporre di un codice in grado di correggere anche un numero limitato di errori

in una parola ricevuta sembrerebbe pertanto essere una scelta quasi obbligata, in realtà

bisogna anche tener presente che le capacità correttive di un codice comportano

1 Per verificarlo è sufficiente esprimere ( ) nella forma (

⁄ ) ( ) ed osservare che se

risulta (

) , pertanto (

) è una funzione decrescente di t .


l’introduzione di una ridondanza cioè l’introduzione di bit non destinati a trasportare

informazione, ciò, a parità di tempo destinato all’invio di una parola, comporta un

aumento della banda, a meno di non voler rallentare il flusso informativo.

Bisogna anche considerare che il confronto tra assenza e presenza di codice

andrebbe fatto a parità d’energia associata al bit informativo, cioè tenendo conto che

parte dell’energia dei bit di informazione non codificati, in presenza di un codice, deve

essere dedicata ai bit di ridondanza, in quanto, a parità di densità spettrale di potenza

del rumore, la sul bit cresce al diminuire della energia ad esso associata, il calcolo

della (9.2.2) andrebbe quindi effettuato introducendo un valore di che tiene conto di

ciò.

Malgrado le considerazioni appena fatte, fin quando è accettabile l’aumento della

banda, l’introduzione di un codice a correzione d’errore è comunque vantaggiosa

rispetto alla trasmissione non codificata.

9.3 - La decodifica a massima verosimiglianza

In quel che segue ci riferiremo a canali BSC ed adotteremo la tecnica di

decodifica a massima verosimiglianza (MV), che, com’è noto, equivale alla maximum

a posteriori probability (MAP) nel caso in cui i bit informativi trasmessi siano

equiprobabili. Osserviamo che in questo caso lo sono anche tutte le parole di e

conseguentemente, in virtù dell’iniettività del codificatore , lo saranno anche tutte le

parole del codice . Sotto quest’ipotesi, indicando con la generica parola di codice,

con la parola ricevuta e con la parola di codice a scelta dal decodificatore, la

regola di decisione sarà:

Regola di decisione a Massima Verosimiglianza

Scegli la parola di codice per la quale è massima la probabilità di ricevere , atteso

che sia la parola trasmessa, in simboli:

( ( )) (9.3.1)

Qualora il massimo non dovesse essere unico, scegli a caso, tra le parole di codice che

lo raggiungono.

***********

Nella precedente e rappresentano VV.AA. multidimensionali che assumono

rispettivamente valori in ed in .

Considerato che nel nostro caso risulta:

( ) ( ) ( ) (

)

( ) (9.3.2)


dove rappresenta il numero di bit in cui differisce da Se

il massimo della

(9.3.2) si raggiunge per tutti i valori di che rendono minimo. qualora ciò avvenisse

in corrispondenza ad un'unica parola di codice, si sceglierebbe quella, se dovessero

esservi più parole per le quali ciò avviene il decodificatore o in armonia con la regola

MV sceglie a caso, o può limitarsi a segnalare la presenza d’errori nella parola ricevuta.

Va da se che l’ultima opzione è praticabile solo se si dispone di un canale di ritorno e

se la trasmissione non deve avvenire necessariamente in tempo reale.

Osserviamo che , è la distanza di Hamming tra e , quindi il criterio di

decisione a massima verosimiglianza su canale BSC consiste in pratica nello scegliere a

caso, tra le parole di codice a minima distanza di Hamming dalla parola ricevuta.

9.4 - Definizioni e teoremi sui codici rivelatori e correttori

Supponiamo che il trasmettitore invii una parola e che per effetto dei disturbi

venga ricevuta una parola diversa da . È immediato constatare che esiste certamente

che ci permette di scrivere . Chiameremo evento o pattern d’errore.

Definizione 9.4

Un pattern di errore è rilevabile se risulta:

(9.4.1)

essendo il complementare di rispetto a .

Viceversa diremo che non è rilevabile se:

(9.4.2)

***********

Ad ogni pattern d’errore corrisponde un peso. Esistono ( ) eventi d’errore di

peso Osserviamo che le posizioni dei bit uno nel pattern d’errore identificano i bit

errati nella parola ricevuta.

Si dice che un codice è in grado di rivelare errori se rivela tutti i pattern di

errore di peso indipendentemente dalla parola di codice trasmessa.

Definizione 9.5

Siano e due parole di . Si definisce distanza minima ( ) di un codice:

( ( ) ( )) (9.4.3)

***********


Teorema 9.1

Condizione necessaria e sufficiente affinché un codice sia in grado di rivelare tutti i

pattern d’errore di peso non superiore a è che risulti .

Dimostrazione:

Necessarietà:

Se il codice è in grado di rivelare tutti gli errori di peso non superiore a , allora,

comunque scelta una parola di codice c ed un pattern d’errore e di peso , la

parola non può essere una parola di codice. Ammettiamo per assurdo che

esisterebbero allora almeno due parole di codice, siano e , tali che

( ) .

Consideriamo il pattern d’errore , risulta:

(9.4.4)

esisterebbe quindi un evento d’errore di peso che non può essere rivelato in quanto

composto con una parola di codice genera un’altra parola di codice.

Sufficienza:

Se e viene ricevuta la parola , con risulta:

( ) ( ) (9.4.5)

la (9.4.5) implica che non può essere una parola del codice poiché ,

l’errore viene pertanto rilevato.

***********

Definizione 9.6

Diciamo che un decodificatore è in grado di correggere un pattern d’errore e se,

quale che sia la parola di codice c , risulta:

( ) ( ) (9.4.6)

Diciamo che un decodificatore è in grado di correggere errori di peso se la

precedente è vera per ogni pattern d’errore di peso .

***********

Teorema 9.2

Condizione necessaria affinché un decodificatore MV sia in grado di correggere tutti i

pattern d’errore di peso non superiore a , è che il codice abbia una .

Dimostrazione:

Supponiamo, per assurdo, che esista un codice in grado di correggere tutti gli

errori di peso non superiore a con . Per detto codice esisterà quindi


almeno una coppia di parole di codice, c e 'c , la cui distanza è . Esistono

certamente due pattern d’errore, siano ed , entrambi di peso non maggiore di , tali

che

(9.4.7)

Nel caso in cui potremo scegliere un pattern d’errore tale che ed

un tale che che soddisfino la precedente.

Supponiamo adesso che venga ricevuta la parola , la sua distanza da

vale quella da vale:

( ) ( ) (9.4.8)

pertanto il decodificatore a massima verosimiglianza decide per , o per una qualsiasi

altra parola di codice che disti non più di da .

Se potremo scegliere due pattern d’errore ed entrambi di peso che

soddisfano la (9.4.7). Supponiamo ancora una volta che venga ricevuta la parola ,

la sua distanza da vale come pure la sua distanza da c pertanto, o il decodificatore

sceglie a caso tra e , ovvero decide a favore di un’altra parola di codice che disti da

, meno di .

***********

Teorema 9.3

Un decodificatore MV è in grado di correggere tutti i pattern d’errore di peso non

superiore a

.

Dimostrazione:

Supponiamo che il canale modifichi una parola di codice c aggiungendovi un

pattern d’errore di peso non superiore a . All’ingresso del decodificatore si presenta

quindi la parola . Quale che sia risulta , in quanto , poiché

dista da meno di , inoltre:

( ) (9.4.9)

osserviamo che il peso di e quello del pattern d’errore è non superiore a

, pertanto, , ( ) , mentre ( ) , quindi il decodificatore MV

in corrispondenza a restituirà ( ) ( ), l’errore verrà quindi corretto.

***********

Capitolo - 10

CODICI LINEARI A BLOCCHI

10.1 - Premessa

Abbiamo visto che un codice a blocco è sostanzialmente un’applicazione

iniettiva tra e con gli bit aggiunti consentono in pratica di

migliorare le prestazioni del sistema introducendo un’opportuna ridondanza ai bit

informativi.

Osserviamo che al crescere di cresce, con legge esponenziale, il numero delle

parole di codice. Ci si rende conto che in queste condizioni la tecnica di decodifica,

consistente in una ricerca esaustiva su una tabella (in pratica un banco di memoria) che

associa ad ogni possibile elemento di l’elemento di che più “verosimilmente” è

stato trasmesso diventa in breve impraticabile a causa delle eccessive dimensioni della

succitata tabella, ovvero perché si preferisce utilizzare la memoria del sistema per altri

scopi.

Queste considerazioni inducono alla progettazione di codici che permettano di

adottare delle tecniche di decodifica di tipo algoritmico, o che quantomeno limitino la

quantità di memoria necessaria per effettuare la ricerca sopra citata.

Tale risultato può essere ottenuto ad esempio se si progetta un codice in modo da

individuare nel sottoinsieme una qualche struttura algebrica. Tanto più ricca sarà tale

struttura, tanto maggiore sarà la possibilità di individuare algoritmi di decodifica

efficienti.

10.2 - Morfismi

È utile introdurre alcune definizioni

Definizione 10.1 - omomorfismo

Un omomorfismo è un’applicazione avente come dominio un gruppo e come

codominio un gruppo tale che

( ) ( ) ( ) (10.2.1)

***********

Nella precedente il segno indica la legge di composizione interna relativa al

gruppo in cui si opera.


Definizione 10.2 - monomorfismo

Un monomorfismo è un omomorfismo iniettivo.

***********

Definizione 10.3 - isomorfismo

Un monomorfismo suriettivo è un isomorfismo.

***********

Si può dimostrare che l’insieme immagine del dominio di un omomorfismo

( ) è un sottogruppo del gruppo d’arrivo. Per sottogruppo s’intende un

sottoinsieme di un gruppo che ha la struttura di gruppo rispetto alla stessa legge di

composizione interna del gruppo in cui è contenuto.

10.3 - Schema di principio di un codice lineare a blocco

Un’importante classe di codici a blocco è quella dei codici lineari. Un

codificatore lineare è concettualmente costituito da (vedi Fig.E 10.1) un registro

d’ingresso dotato di celle, da un banco di sommatori ciascuno dei quali con un

numero di ingressi compreso tra e e da un registro di uscita costituito da celle

connesse alle uscite dei sommatori corrispondenti. Questi ultimi, nel caso dei codici

binari, effettuano le somme in . Conveniamo che un sommatore con un solo ingresso

equivale ad una connessione diretta tra la cella d’ingresso e quella di uscita

corrispondente al sommatore.

I registri sopra citati possono essere in pratica registri a scorrimento (shift

register), in questo caso la sorgente emette una sequenza di bit, non appena il registro

d’ingresso è carico, cioè dopo periodi del suo clock, l’uscita dei sommatori, che

potrebbero essere realizzati con delle porte logiche di tipo XOR, viene utilizzata per

settare le celle del registro di uscita che verrà quindi completamente scaricato nel

tempo necessario a ricaricare con i successivi bit il registro di ingresso.

Fig.E 10.1 Schema di principio di un codice di Hamming 15,11

Codici Lineari a Blocchi 83

In sostanza, se e indicano rispettivamente i periodi di clock del

registro d’ingresso e di quello d’uscita, deve risultare .

10.4 - Matrice generatrice del codice

I codici lineari a blocco sono anche chiamati codici a controllo di parità (parity

check code) in quanto il generico elemento del registro d’uscita, vale uno ogniqualvolta

la somma in senso ordinario dei valori delle celle di ingresso a cui è connesso è un

numero dispari e vale zero altrimenti.

Se indichiamo con una parola di e con ( ) la corrispondente parola di

in uscita dal codificatore, l’ esimo bit della parola d’uscita può esprimersi nella

forma:

(10.4.1)

dove il generico è un coefficiente che vale se un ingresso del -esimo sommatore

è connesso alla -esima cella del registro di ingresso e vale altrimenti.

Ricordiamoci che tutte le operazioni delle (10.4.1) sono effettuate secondo le

regole del campo .

Un codice definito tramite le (10.4.1) si dice lineare in quanto, come si verifica

facilmente, la parola di codice ottenuta in corrispondenza alla somma di due qualsiasi

parole di è la somma in delle rispettive parole di codice.

e sono gruppi, ed un codificatore lineare è un omomorfismo, ovviamente,

è auspicabile che sia anche un monomorfismo, onde evitare che a due parole distinte di

corrisponda la stessa parola di codice in .

Il codice è pertanto un sottogruppo di .

Se pensiamo e come vettori riga le (10.4.1) si possono rappresentare sotto

forma matriciale:

(10.4.2)

dove è una matrice il cui generico elemento è . è detta matrice

generatrice del codice.

Si osservi che le righe della matrice , sono le parole di codice che vengono

generate in corrispondenza agli elementi che costituiscono la base canonica di . Ci si

convince anche abbastanza facilmente del fatto che le righe di generano mediante

tutte le loro possibili combinazioni lineari , che oltre ad essere un sottogruppo di

ne è anche un sottospazio. Ovviamente affinché il codice non sia ambiguo deve

essere un monomorfismo.


Una condizione necessaria e sufficiente affinché sia un monomorfismo è che le

righe della sua matrice generatrice siano linearmente indipendenti.

10.5 - Distribuzione dei pesi di un codice lineare a blocco

Abbiamo detto che la somma di due parole di un codice lineare è una parola di

codice, ciò comporta che la parola identicamente nulla in un codice lineare è sempre

una parola di codice, in quanto ottenibile sommando ad una qualunque parola del

codice se stessa, indicando con la parola identicamente nulla per un codice lineare

avremo:

( ) ( ) (10.5.1)

ma, per fissato , al variare di in si ottengono tutte le parole di codice, in sostanza

fissata una distanza di Hamming ogni parola di un codice lineare vedrà lo stesso

numero di parole di codice a quella distanza. Tale proprietà si rivela utile ad esempio

nel calcolo della probabilità d’errore in quanto la probabilità d’errore condizionata

all’invio di una parola di codice non dipende dalla particolare parola inviata, ed è

quindi uguale alla probabilità d’errore non condizionata.

Dalla (10.5.1) si deduce inoltre facilmente che per calcolare la distanza minima

del codice è sufficiente individuare la parola non nulla di peso minimo, che è

evidentemente la parola a minima distanza di Hamming dalla parola nulla, ovviamente

non è detto che tale parola sia unica.

La (10.5.1) ci suggerisce di introdurre la cosiddetta distribuzione dei pesi del

codice.

Definizione 10.4

Dato un codice lineare per distribuzione dei pesi s’intende una applicazione

( ), definita sull’insieme dei naturali non maggiori di , a valori in ; che associa

ad ogni elemento del suo dominio il numero di parole di codice che hanno peso pari ad

esso.

***********

È facile intuire che le prestazioni di un codice sono in prima istanza influenzate

dalla sua distanza minima, che coincide con il più piccolo elemento non nullo del

dominio di ( ) cui corrisponde un’immagine diversa da zero, ma dipendono anche

dalla ( ) nel suo insieme.


10.6 - Capacità di rivelazione di un codice lineare a blocco

Per la capacità di rivelazione di un codice lineare a blocco vale il seguente

teorema:

Teorema 10.1

Un decodificatore a massima verosimiglianza per un codice lineare non è in grado di

rivelare tutti e soli gli eventi d’errore che coincidono con una parola di codice.

Dimostrazione:

Se il canale fa sì che ad una parola di codice venga aggiunto un pattern d’errore

che coincide con una parola di codice in ingresso al decodificatore si presenterà la

parola , ma il codice è lineare quindi è una parola di codice pertanto

l’errore non sarà rivelato.

Viceversa se un pattern d’errore non viene rivelato, allora deve esistere una

parola di codice tale che essendo è la parola trasmessa. L’eguaglianza

appena scritta comporta:

(10.6.1)

pertanto è una parola di codice.

***********

10.7 - Probabilità di non rivelazione d’errore di un codice lineare

Ci proponiamo di calcolare la probabilità che un codice lineare, impiegato per la

sola rivelazione d’errore, non ne riveli la presenza nella parola ricevuta, sotto l’ipotesi

che il codice venga utilizzato su un canale BSC e che il decodificatore sia del tipo MV.

Sappiamo che (vedi Teorema 10.1) gli unici pattern d’errore non rivelati sono

quelli che coincidono con una parola di codice. Osserviamo che la probabilità che si

presenti un dato pattern d’errore dipende esclusivamente dal suo peso e vale in

particolare:

( ) (10.7.1)

Tra tutti gli ( ) possibili pattern d’errore di peso non verranno rivelati soltanto quelli

che coincidono con una parola di codice, cioè tanti quante sono le parole di codice di

quel peso. Poiché i pattern d’errore sono tra loro indipendenti, la probabilità ( )

che un errore non venga rivelato dal codice vale:

( ) ∑ ( )

( ) (10.7.2)


La precedente presuppone la conoscenza della distribuzione dei pesi, purtroppo

detta funzione non è nota per molti dei codici d’uso comune, in questo caso può essere

utile una maggiorazione della (10.7.2) che si basa sulla considerazione che in ogni caso

deve essere:

( ) (

) (10.7.3)

non possono cioè esservi più pattern d’errore di peso di quante non siano le parole di

aventi quel peso. Potremo quindi certamente scrivere:

( ) ∑ (

)

( ) (10.7.4)

10.8 - Laterali di un sottogruppo

In questo paragrafo per comodità utilizzeremo la notazione moltiplicativa per

indicare la legge di composizione di un gruppo, indicheremo quindi con l’elemento

neutro del gruppo, consideriamo un gruppo abeliano ed un suo sottogruppo .

Ricordiamoci che, per definizione di sottogruppo, è chiuso rispetto alla legge di

composizione di .

Consideriamo adesso un generico elemento non appartenente a , se

componiamo questo elemento con gli elementi di otteniamo un sottoinsieme di

disgiunto da . Se infatti risultasse che, per un qualche elemento di ,

, ciò implicherebbe che e quindi , ma se

allora essendo gruppo vi appartiene anche , contro l’ipotesi. viene denominato

laterale, coinsieme o coset di .

Consideriamo adesso, se esiste, un elemento che non appartiene né a né a ,

sia . Anche , composto con gli elementi di , genera un sottoinsieme di ov-

viamente disgiunto da , ma anche da ; se infatti esistesse tale che

, ciò implicherebbe che implicherebbe contro l’ipotesi.

Possiamo quindi concludere che i laterali di un sottogruppo se non sono disgiunti sono

coincidenti.

Appare chiaro che ogni sottogruppo di un gruppo induce una partizione in laterali

del sottogruppo. Si può facilmente verificare che tutti i laterali hanno la stessa

cardinalità del sottogruppo cui sono associati e che ogni elemento di un laterale,

composto con gli elementi del sottogruppo, è in grado di generare il laterale cui

appartiene. È quindi legittimo scegliere in corrispondenza a ogni laterale un suo


elemento, che viene denominato rappresentante di laterale o di coinsieme, o ancora

coset leader. Il criterio di scelta può essere qualsiasi.

Ricordiamoci che stiamo considerando gruppi abeliani, se rimuovessimo questa

ipotesi ad ogni sottogruppo potrebbero essere associati dei laterali destri e sinistri,

generalmente distinti, qualora tali laterali dovessero coincidere si direbbe che il

sottogruppo considerato è un sottogruppo normale.

Il fatto che tutti i laterali di un sottogruppo hanno la stessa cardinalità consente di

affermare, nel caso di gruppi finiti, che ogni sottogruppo ha un numero d’elementi

sottomultiplo di quello del gruppo in cui è contenuto.

10.9 - Decodifica tramite i rappresentanti di laterale

Tornando ai codici lineari a blocco ( ), ricordiamo che l’insieme delle parole

di un tale codice costituisce un sottogruppo . Abbiamo anche mostrato che un

codice lineare a blocco è in grado di rivelare tutti i pattern d’errore che non coincidono

con parole di codice.

Occupiamoci adesso delle sue capacità correttive. A tal proposito osserviamo che

ogni parola ricevuta appartiene ad un solo laterale di rispetto a , intendendo

ovviamente stesso come un laterale. Risulta inoltre , il pattern d’errore

introdotto dal canale appartiene quindi certamente allo stesso laterale cui appartiene .

Visto che la probabilità che il canale introduca un pattern d’errore di un dato peso

decresce al crescere di quest’ultimo, l’ipotesi più verosimile è che il pattern d’errore

introdotto coincida con una parola di peso minimo appartenente allo stesso laterale

della parola ricevuta.

Le considerazioni appena fatte portano alla seguente tecnica di decodifica: dato

un codice scegliamo come rappresentante di ogni suo laterale la parola di peso

minimo appartenente a esso. Nel caso in cui nel laterale vi siano più parole di peso

minimo ne sceglieremo una a caso. Osserviamo che, quale che sia la parola ricevuta,

essa si potrà scrivere in modo univoco nella forma essendo il coset leader

del laterale a cui essa appartiene. Comunque scelta una parola di codice risulta:

( ) ( ) (10.9.1)

in quanto è una parola di che appartiene allo stesso laterale di , visto che

è una parola di codice, ed è per ipotesi una parola di peso minimo di quel

laterale, pertanto se adottiamo la decodifica ML dobbiamo necessariamente scegliere la

parola .


Se nello stesso laterale più di una parola ha peso minimo, ciò significa che la

parola ricevuta si trova alla stessa distanza da due o più parole di codice, in questo

caso, quale che sia la scelta effettuata tra le parole candidate, le prestazioni del

decodificatore non cambiano.

Si osservi che qualora la parola ricevuta appartenga al codice tale operazione non

la altera in quanto il rappresentante di laterale relativo a è unico ed è ovviamente la

parola identicamente nulla.

Quanto sopra detto ci porta ad enunciare il seguente

Teorema 10.2

Un decodificatore che adotta la tecnica dei coset leader corregge tutti e soli i pattern

d’errore coincidenti con un coset leader.

***********

Un vantaggio della decodifica basata sui coset leader è quello di restituire sempre

una parola di codice, ovviamente non sempre quella corretta. Il suo principale

svantaggio consiste nel fatto che per metterla in pratica occorre comunque effettuare

una ricerca in tutto per individuare il laterale cui appartiene la parola, se è grande

tale ricerca può diventare troppo onerosa.

10.10 - Probabilità d’errore di un codice lineare a blocchi

Il Teorema 10.2 ci suggerisce come calcolare la probabilità di corretta decisione

di un codice, impiegato su un canale BSC.

Osserviamo innanzitutto che all’uscita del decodificatore sarà presente la parola

effettivamente inviata tutte e sole le volte che il pattern d’errore introdotto dal canale

coincide con un coset leader, considerando anche tra i pattern d’errore quello

identicamente nullo che è il coset leader del codice.

La coinciderà quindi con la probabilità che il pattern d’errore sia un qualsiasi

coset leader. Possiamo quindi scrivere:

∑ ( ) ( )

(10.10.1)

dove rappresenta il massimo peso raggiunto dai coset leader ed ( ) un’applicazione

che associa ad ogni intero compreso tra ed il numero di coset leader di peso .

Dalla (10.10.1) discende facilmente:

∑ ( ) ( )

(10.10.2)


10.11 - Codici perfetti, bound di Hamming

Una maggiorazione della probabilità d’errore può essere ottenuta ricordando il

Teorema 9.3, che afferma che la capacità correttiva di un codice è non minore di

. In altri termini il teorema afferma che la regione di decisione di ciascuna

parola di codice contiene una “ipersfera” di raggio pari a . In che contiene

esattamente ∑ ( )

punti.

Osserviamo che in un codice lineare tutte le regioni di decisione hanno la stessa

forma e che l’insieme dei coset leader costituisce la regione di decisione associata alla

parola nulla. Vi sono laterali, quindi coset leader. Il Teorema 9.3 nel caso di

codici lineari implica quindi che deve valere la disuguaglianza:

∑( )

∑ ( )

(10.11.1)

la precedente va sotto il nome di Bound di Hamming i codici che lo soddisfano come

uguaglianza sono detti codici perfetti.

Quale che sia il codice lineare che stiamo considerando, i primi addendi

dell’ultimo membro della (10.11.1) devono necessariamente essere uguali ai

corrispondenti addendi della sommatoria a primo membro, possiamo pertanto scrivere:

∑ ( ) ( )

∑( )

( )

∑( )

( ) ∑ ( )

( )

(10.11.2)

la precedente è ovviamente soddisfatta come uguaglianza solo dai codici perfetti, quali

sono ad esempio i codici di Hamming cui accenneremo più avanti.

Capitolo - 11

CODICI SISTEMATICI

11.1 - Codici Sistematici

Quanto detto nei precedenti paragrafi ci fa comprendere che le prestazioni di un

codice lineare sono da attribuirsi sostanzialmente al sottospazio di generato dalle

righe della matrice che supporremo linearmente indipendenti e che quindi

costituiranno una base per il sottospazio da esse generato. In sostanza quindi codici ge-

nerati da matrici distinte, delle stesse dimensioni, che generano però lo stesso sotto-

spazio di sono del tutto equivalenti.

Lo spazio generato dalle righe di non cambia se si permutano le sue righe, o se

si somma ad una qualunque riga di una combinazione lineare delle restanti.

Dato un codice lineare a blocchi, consideriamo la sua matrice e selezioniamone

una sua colonna non identicamente nulla. Supponiamo sia la -esima. Consideriamo

quindi una riga di che abbia un nella -esima colonna, supponiamo sia la -esima,

sommiamo tale riga a tutte le altre righe di che si trovano nelle stesse condizioni.

Otterremo così una matrice, sia ( ), equivalente a la cui -esima colonna ha un solo

valore in posizione -esima. Operiamo adesso sulla matrice ( ) come avevamo

operato sulla con la sola accortezza di scegliere una colonna che abbia un in una

riga diversa dalla -esima, otterremo così una ( ) con due colonne che presentano un

solo valore su righe diverse. All’ -esimo passo sceglieremo una colonna che abbia un

in una riga diversa da quelle selezionate ai passi precedenti.

Tale procedura potrà essere ripetuta al più volte, a meno che non sia più

possibile selezionare una colonna, ma ciò accade solo nel caso in cui tutte le righe non

ancora selezionate sono identicamente nulle, in questo caso le righe della matrice da

cui eravamo partiti non erano linearmente indipendenti, quindi non erano in grado di

generare un sottospazio di dimensione , o, che è lo stesso, il codificatore non era un

monomorfismo di in cioè avevamo preso in considerazione un codice ambiguo.

Al termine della procedura sopra descritta avremo quindi una matrice ( ) che ha

almeno colonne in cui compare un solo , tra le colonne con un solo ne esisterà

almeno una che lo ha in corrispondenza alla prima riga, una in corrispondenza alla

seconda e cosi via fino alla -esima.

A questo punto è opportuno osservare che se s’intende utilizzare il codice su un

canale simmetrico binario, ovvero mappando coppie di bit della parola d’uscita in punti


di una costellazione QAM, è anche legittimo permutare le colonne della matrice ,

questa operazione equivale in sostanza ad etichettare diversamente le dimensioni dello

spazio .

È ovvio che permutando opportunamente le colonne della ( ) si può ottenere

una matrice del tipo:

(11.1.1)

un codice lineare a blocchi la cui matrice generatrice assume la forma (11.1.1) si dice

sistematico tale denominazione è dovuta al fatto che i primi bit della parola di codice

coincidono con i bit informativi, i restanti sono utilizzati per effettuare i controlli

di parità definiti dalle colonne della matrice .

In pratica in corrispondenza a ogni codice lineare a blocco non ambiguo esiste un

codice sistematico ad esso equivalente. L’utilizzo dei codici sistematici è quindi

auspicabile, in quanto, solo per fare un esempio, consente di non effettuare nessuna

decodifica sulla parola ricevuta, limitandosi ad osservarne i primi bit, accettando in

questo caso un degrado delle prestazioni a fronte di una diminuzione della complessità

del sistema.

11.2 - Matrice di controllo di parità

Dato un codice lineare a blocco sistematico, indichiamo con la generica

parola d’ingresso e con la generica parola di codice. Se prendiamo in considerazione

soltanto le ultime componenti della parola di codice, ponendo

possiamo scrivere:

[

] (11.2.1)

sostituendo a la sua espressione in termini della matrice otteniamo:

[

] [

] ( )

(11.2.2)

Sempre in virtù del fatto che il codice è sistematico possiamo scrivere anche:

(11.2.3)

che ci suggerisce di riscrivere l’ultima eguaglianza nella (11.2.2) nella forma:

[

] (11.2.4)

La matrice che compare nella precedente prende il nome di matrice di

controllo di parità (parity check matrix), in quanto la (11.2.4) è soddisfatta da tutte e

sole le parole di codice.

Codici Sistematici 93

11.3 - Codici duali

Osserviamo che la (11.2.4) implica l’ortogonalità tra la generica parola di codice

e ogni riga della matrice , le cui righe essendo linearmente indipendenti sono in

grado di generare un sottospazio di ortogonale a , nel senso che

combinando linearmente le righe di si ottengono sempre parole di ortogonali a

qualsiasi parola di .

Ci si rende facilmente conto del fatto che si può pensare a come ad un

codice ( ).

Permutando opportunamente le colonne della matrice si può sempre rendere

sistematico, in un certo senso lo è anche senza permutarle, solo che in questo

caso i bit informativi coincidono con gli ultimi bit della parola di codice.

11.4 - Decodifica basata sulla sindrome

Supponiamo di ricevere una parola , affetta da un pattern d’errore . Se so-

stituiamo a primo membro della (11.2.4) otteniamo:

(11.4.1)

è una parola di bit che prende il nome di sindrome della parola ricevuta. Vi

sono possibili sindromi.

È interessante osservare che il calcolo della sindrome può essere effettuato in

ricezione con uno schema analogo a quello utilizzato per il codificatore, dimensionando

correttamente i due registri a scorrimento. Il calcolo della sindrome nei codici a

rivelazione d’errore consente verificare facilmente se la parola ricevuta appartiene al

codice solo le parole di codice hanno infatti sindrome nulla.

Nel caso dei codici a correzione d’errore, osservando la (11.4.1) si rileva che tutti

gli elementi di uno stesso laterale del codice hanno la stessa sindrome. Tutti gli

elementi di un laterale si ottengono infatti sommando ad un qualsiasi elemento del

coset stesso una parola di codice. È altresì chiaro che elementi appartenenti a laterali

distinti avranno sindromi distinte. In sostanza esiste una corrispondenza biunivoca tra il

gruppo delle sindromi e l’insieme dei laterali che è esso stesso un gruppo, detto gruppo

quoziente indicato con

⁄ . La composizione tra due laterali del gruppo quoziente

si effettua individuando il coset di appartenenza dell’elemento di ottenuto

componendo due elementi arbitrariamente scelti nei due laterali componendi.

Si constata che il gruppo delle sindromi è isomorfo al gruppo quoziente di

individuato dal suo sottogruppo .


La decodifica a massima verosimiglianza può quindi essere effettuata associando

preliminarmente ad ogni sindrome il coset leader nel laterale ad essa associato, da

sommare alla parola ricevuta per effettuare la decodifica. Tale tecnica comporta la

presenza di un banco di memoria in grado di contenere parole di bit.

In effetti essendo interessati solo ai bit informativi è sufficiente memorizzare

soltanto i primi bit del coset leader, questo accorgimento riduce un po’ il fabbisogno

di memoria.

La decodifica basata sulla sindrome è più efficiente di quella basata sui coset

leader, anche se, al crescere delle dimensioni della parola di codice, diventa ben presto

impraticabile, a causa della quantità di memoria di cui necessita.

Capitolo - 12

Codici di Hamming e loro duali

12.1 - Codici di Hamming

Abbiamo visto come si calcola la sindrome di un codice ed abbiamo osservato

che più pattern d’errore possono condividere la stessa sindrome. Immaginiamo adesso

di voler costruire un codice che abbia la capacità di correggere tutti i pattern d’errore di

peso . Affinché ciò sia possibile ciascun pattern d’errore di peso deve essere un

coset leader.

Abbiamo visto che un codice ( ) consta di parole di bit. Esistono quindi

distinti pattern d’errore di peso , ciascuno dei quali, moltiplicato per fornisce la

rispettiva sindrome. Detta sindrome coincide con la colonna della matrice che

corrisponde alla posizione dell’unico bit nel pattern d’errore. Quindi, se vogliamo che

il codice sia in grado di correggere tutti i pattern d’errore di peso , è necessario che le

colonne della matrice siano tutte diverse tra loro e non nulle. Poiché ogni colonna

della matrice in questione ha elementi, deve necessariamente essere:

(12.1.1)

La precedente scritta come uguaglianza definisce implicitamente una famiglia di

codici, i codici di Hamming, che sono in grado di

correggere tutti gli errori di peso e di rivelare

quelli di peso non superiore a due in quanto si

può mostrare che la loro vale . Alcune

soluzioni della (12.1.1) sono riportate nella in

Tabella 12.1.

Il primo codice della tabella è in effetti un

codice a ripetizione, in sostanza ogni bit informativo viene inviato consecutivamente

tre volte, vi sono due sole parole di codice, la distanza di Hamming tra esse, quindi

anche la del codice, è , il codice è in grado di correggere errori singoli, la regola

di decisione a massima verosimiglianza per questo codice consiste nello scegliere il bit

che compare almeno due volte nella parola ricevuta. Se il canale introduce un errore

doppio il codice rileva l’errore, ma non è in grado di correggerlo, nel senso che

restituisce una parola di codice diversa da quella inviata nel caso di decodifica MV. Vi

sono tre laterali del codice a ciascuno di essi appartiene un pattern d’errore singolo e il

suo negato.

𝑛 𝑘 3 1

7 4

15 11

31 26

63 57

127 120

Tabella 12.1 Alcuni valori di 𝑛 e 𝑘 per

i codici di Hamming


Per concludere si può facilmente verificare che la (10.11.1) è verificata come

uguaglianza per tutti i codici di Hamming risulta infatti:

⌊

⌋ (12.1.2)

da cui

∑ ( )

(12.1.3)

ma per i codici di Hamming , i codici di Hamming appartengono pertanto

all’insieme dei codici perfetti.

Esempio 12.1

Una possibile matrice del secondo codice della Tabella 12.1, il 7,4,è data da:

[

]

Osserviamo che la matrice in

esame ha per colonne tutte le parole di

tre bit ad esclusione di quella costituita

da soli zero, ordinate in modo da

rispettare la (11.2.4).

Ricordiamoci che le prime quattro

colonne di possono essere permu-

tate tra loro senza che le caratteristiche

del codice cambino.

Basandoci sulla (11.2.4) e sulla

(11.1.1) potremo facilmente scrivere la

matrice generatrice del codice:

[

]

il relativo schema a blocchi è mostrato in Fig.E 12.1, la lista delle

parole del codice è elencata nella Tabella 12.2 dove ogni parola è stata

suddivisa tra contenuto informativo (i primi 4 bit) e controlli di parità

(gli ultimi 3).

Uno schema a blocchi del codice di Hamming 15,11 è mostrato in

Fig.E 10.1.

12.2 - Duali dei codici di Hamming

Nel caso dei duali dei codici di Hamming, le colonne

della loro matrice generatrice sono tutte e sole le parole bi-

narie non nulle che si possono scrivere con bit vi saranno

quindi esattamente colonne nella matrice genera-

trice. La matrice definisce quindi un codice ( ) , le cui parole non nulle

hanno tutte peso .

Infatti ogni riga della matrice generatrice contiene per costruzione bit

zero e bit uno. Le restanti parole del codice si ottengono combinando linearmente

Codice di Hamming 7,4 0000 000 0001 111 0010 011 0011 100 0100 101 0101 001 0110 110 0111 001 1000 110 1001 001 1010 101 1011 010 1100 011 1101 100 1110 000 1111 111

Tabella 12.2 - Parole del

codice Hamming 7.4

Fig.E 12.1 - Schema a blocchi del Codice 7,4 di Hamming

Codici di Hamming e loro Duali 97

le righe della matrice generatrice, tale combinazione lineare, a ben vedere, consiste nel

cancellare un sottoinsieme di righe dalla matrice generatrice e sommare le restanti.

Per semplificare il ragionamento immaginiamo di aggiungere alla matrice una

colonna nulla, sia la matrice estesa così ottenuta. Osserviamo che le parole del codice

( ) generato da differiscono da quelle generate da solo per il fatto di avere un

bit in più, che essendo generato dalla colonna identicamente nulla, vale sistemati-

camente . Possiamo quindi affermare che le parole corrispondenti dei due codici, cioè

generate dalla stessa parola di hanno lo stesso peso.

Osserviamo adesso che la cancellazione di una riga in da luogo ad una

sottomatrice ( ) che ha le colonne uguali a due a due; se cancellassimo due righe

avremmo una sottomatrice ( ) con colonne uguali a quattro a quattro e così via.

In generale quindi cancellando righe di , con 0 j k , avremo una

sottomatrice ( ) di righe con solo colonne distinte che non potranno essere

altro se non tutte le parole binarie di bit.

Il peso della parola di codice ottenuta componendo le righe di ( ) , è

uguale al numero di colonne che hanno un numero dispari di al loro interno. Ci si

convince facilmente che esattamente la metà delle colonne diverse tra loro hanno

peso dispari. Il peso della parola di codice ottenuta componendo le righe vale

, indipendente dal numero di righe cancellato, pur di non cancellarle

tutte, in questo caso otterremo la parola di codice nulla che ha peso .

Possiamo quindi concludere che la distanza minima per codici generati da matrici

di tipo , o da matrici di tipo vale , che è anche, la distanza tra due parole di

codice qualsiasi.

12.3 - Codici ortogonali e transortogonali

Immaginiamo di utilizzare un codice generato da una matrice del tipo ,

introdotta nel paragrafo 12.1 - , con una segnalazione di tipo antipodale, associando

cioè ai bit un impulso di segnalazione in banda base ( ) (la cui durata, per

semplicità possiamo pensare sia non maggiore dell’intervallo di segnalazione ), e ai

bit il suo opposto. Alla generica parola di codice verrà quindi associato il segnale in

banda base:

( ) ∑( ) ( ( ) )

(12.3.1)


Se effettuiamo il prodotto scalare tra i segnali associati a due distinte parole di codice

otteniamo:

∫ ∑( ) ( ( ) ) ∑( ) ( ( ) )

∑∑( ) ( )

∫ ( ( ) ) ( ( ) )

∑( ) ( ) ∫ ( ) ( )

∑( ) ( )

∑( )(

)

(12.3.2)

nella precedente indica l’energia del bit informativo, conseguentemente l’energia

specifica dell’impulso di segnalazione, che tiene conto del Rate

del codice, vale

. La sommatoria a ultimo membro vale in quanto la distanza di Hamming tra due

parole di codice distinte vale .

Sotto le ipotesi appena fatte i segnali associati alle parole del codice generato

dalla matrice di parità estesa di un codice di Hamming sono a due a due ortogonali.

Per quanto riguarda i codici duali dei codici di Hamming, nelle stesse condizioni

generano un set di segnali isoenergetici in uno spazio a dimensioni. Detti

segnali non sono più mutuamente ortogonali, anche se la distanza tra una qualunque

coppia di segnali è la stessa. I codici duali dei codici di Hamming si chiamano

transortogonali. Rispetto ai codici generati da matrici di tipo i codici transortogonali

hanno il vantaggio a parità d’energia di consentire un aumento dell’energia

associata al bit della parola di codice, in virtù del rate più basso, per questo le loro

prestazioni sono leggermente migliori.

Capitolo - 13

CODICI CONVOLUZIONALI

13.1 - Premessa

I codici convoluzionali furono proposti per la prima volta da P. Elias nel 1955,

ma hanno trovato ampia applicazione dopo che A. J. Viterbi propose nel 1967 un

efficiente algoritmo di decodifica. Nei codificatori convoluzionali la parola prodotta

non dipende soltanto dalla parola emessa dalla sorgente al tempo presente, ma anche da

quelle emesse precedentemente. Si tratta quindi di un codificatore dotato di memoria.

13.2 - Struttura del codificatore

Lo schema di principio di un codificatore convoluzionale è mostrato in Fig.E

13.1. Dove i simboli emessi dalla

sorgente appartengono a un alfabeto di

cardinalità assegnata ed i sommatori

operano modulo la cardinalità

dell’alfabeto.

Lo schema di Fig.E 13.1, a prima

vista, non differisce da quello di un codi-

ficatore per codici a blocchi, se non fos-

se per la dimensione dello shift register

d’ingresso che è maggiore di quello d’u-

scita. La differenza sostanziale tra il

codificatore di figura e quello di uno a blocchi, consiste nel fatto che il registro

d’uscita, nel codificatore di figura, viene letto ogni due simboli emessi dalla sorgente.

In generale in un codificatore convoluzionale il numero di simboli che co-

stituiscono la parola informativa è un sottomultiplo della lunghezza dello shift register

d’ingresso. Il rapporto tra il numero di celle dello shift register e il numero di simboli di

sorgente che costituiscono la parola informativa viene denominato lunghezza di

vincolo (costraint lenght) ( in quel che segue).

Da quanto appena detto segue che la parola di codice non dipende soltanto dalla

parola d’ingresso attuale ma anche dalle parole emesse precedentemente dalla

sorgente.

Nello schema di Fig.E 13.1 la lunghezza di vincolo , la parola di codice

dipende pertanto dalla parola corrente e dalle 2 parole informative che la precedono.

Fig.E 13.1 - Schema di principio di un codificatore

convoluzionale


Anche nei codificatori convoluzionali si può definire un rate espresso dal rapporto tra la

lunghezza della parola informativa (2 in Fig.E 13.1) e quella della parola di codice

generata (3 in Fig.E 13.1). A differenza dei codici a blocchi le lunghezze, sia delle

parole d’ingresso, sia di quelle di codice, sono piccole (dell’ordine delle unità), i

simboli utilizzati appartengono tipicamente a .

13.3 - Matrice generatrice e generatori.

I codificatori convoluzionali come si evince dalla Fig.E 13.1 figura del paragrafo

precedente sono lineari.

Osserviamo che, se la

lunghezza di vincolo

fosse unitaria, degenere-

rebbero in un codifica-

tore a blocco. Se la lun-

ghezza di vincolo è

maggiore di uno la se-

quenza d’uscita dipende

dall’intera sequenza in

ingresso. In ogni caso

possiamo affermare che

la sequenza codificata

associata a una generica

sequenza informativa

può sempre essere ottenuta come combinazione lineare delle risposte che il codificatore

genererebbe in corrispondenza a sequenze “canoniche”, cioè a sequenze seminfinite

contenenti un unico bit .

In Tabella 13.1 sono mostrate le sequenze d’uscita che si otterrebbero dall’analisi

del codificatore Fig.E 13.1 in corrispondenza alle citate sequenze, assumendo che in

assenza di una sequenza in ingresso tutte le celle dello shift register contengano il bit 0.

Le sequenze codificate della tabella si possono pensare come le righe di una matrice

generatrice del codice. Detta matrice ha dimensioni semi infinite, motivo questo di per

sé sufficiente per cercare un approccio più efficiente allo studio dei codici in parola.

È interessante osservare che la matrice generatrice ha una struttura ben precisa,

come si desume dalla Tabella 13.1essa è a blocchi del tipo:

Sequenze di

ingresso Sequenze codificate

10 00 00 00 0… 001,100,001,000…

01 00 00 00 0… 010,010,100 000…

00 10 00 00 0… 000,001,100,001 000…

00 01 00 00 0… 000,010,010,100 000…

00 00 10 00 0… 000,000,001,100,001,000

00 00 01 00 0… 000,000,010,010,100 000…

00 00 00 10 00 0… 000,000,000,001,100,001,000

00 00 00 01 00 0… 000,000,000,010,010,100 000…

Tabella 13.1 - sequenze di uscita del codificatore di Fig.E 13.1 in

corrispondenza alle sequenze canoniche

Codici Convoluzionali 101

[

] (13.3.1)

dove le rappresentano matrici e gli zeri indicano matrici nulle delle stesse

dimensioni. Osservando la struttura della generica ci si rende conto che essa è in

realtà la matrice generatrice di un codice a blocchi , il suo generico elemento

vale cioè solo se l’ -esima cella dell’ -esimo blocco dello shift register di ingresso è

connessa al sommatore - esimo.

La (13.3.1) è di scarsa utilità pratica. Le matrici potrebbero essere si usate

per descrivere la struttura del codificatore, ma, anche a questo scopo, esse si rivelano in

genere meno efficienti dei cosiddetti generatori. I generatori sono vettori binari

ciascuno con componenti. Dove la -esima componente dell’ -esimo generatore

vale solo se l’ -esimo sommatore è connesso all’ -esima cella del registro

d’ingresso.

Per il codificatore di Fig.E 13.1 i generatori sono:

(13.3.2)

Noto il rate del codificatore i generatori permettono di tracciare facilmente lo schema

del codificatore.

Il vantaggio che si ha nell’utilizzo dei generatori rispetto all’uso delle matrici

costituenti la matrice generatrice è legato al fatto che i generatori sono in numero pari

al numero di bit della parola d’uscita dell’ordine delle unità, mentre le matrici in parola

sono in numero pari alla lunghezza di vincolo che può essere dell’ordine delle decine.

Inoltre i generatori si prestano a essere rappresentati in notazione diversa da quella

binaria, tipicamente quella ottale, rappresentando cioè gruppi di tre bit con la

corrispondente cifra ottale per il nostro codificatore ciascun generatore si può

rappresentare mediante due cifre ottali in particolare per il nostro esempio si ha:

(13.3.3)

13.4 - Diagramma di stato del codificatore.

La matrice generatrice, non è certamente uno strumento di semplice impiego per

analizzare un codificatore convoluzionale. I generatori sono sì uno strumento efficace

per descrivere la struttura del codificatore, ma mal si prestano al calcolo della sequenza

che esso genera in uscita. Un modo alternativo, certamente più efficace, per descrivere


il comportamento del codificatore è quello di tener conto del fatto che l’uscita prodotta

in un certo istante dipende oltre che dalla parola d’ingresso corrente anche dalla storia

della sequenza d’ingresso, in particolare l’uscita dipende dai ( ) bit d’ingresso

che hanno preceduto la parola corrente.

In altri termini, noti i ( ) bit precedenti e i bit della parola corrente,

possono essere determinati univocamente, sia l’uscita corrente, sia i ( ) bit che

contribuiranno unitamente alla parola d’ingresso successiva a determinare la parola

d’uscita seguente. Osserviamo che esistono esattamente ( ) contenuti distinti per le

celle del registro che costituiscono la memoria del sistema. Possiamo dire pertanto che

il codificatore può assumere ( ) stati diversi (16 nel nostro esempio). L’arrivo di

una parola d’ingresso comporta tipicamente una variazione del contenuto della memo-

ria, quindi una variazione dello stato del sistema. In sostanza un codificatore convo-

luzionale non è altro che una macchina a stati finiti.

Gli stati del codificatore possono essere associati ai vertici di un grafo (vedi

Esempio 3.1) due vertici vengono connessi tramite un lato se esiste una parola di

ingresso che induce la transizione tra i due stati. Ad ogni lato potremo associare

un’etichetta che contiene la parola d’ingresso ad esso relativa, ma anche la

corrispondente parola di uscita che dipende dal vertice da cui il suddetto lato fuoriesce.

Osserviamo che da ogni vertice origineranno e si dipartiranno esattamente

lati, tanti quante sono le possibili parole d’ingresso (nel nostro esempio 4). Quindi ogni

vertice è di grado ( ). Il grafo è anche connesso in quanto, comunque scelti due

vertici distinti, esiste sempre un

percorso che li congiunge,

osserviamo che tale percorso è

costituito al più da ( ) lati.

Il grafo relativo al codifica-

tore di Fig.E 13.1 è mostrato in

Fig.E 13.2 dove si sono utilizzati

colori diversi per distinguere le

parole d’ingresso associate ai lati.

Nella stessa figura si sono

indicate solo alcune parole

d’uscita per non pregiudicarne la

leggibilità.

Fig.E 13.2 - Grafo del codificatore mostrato in Fig.E 13.1


Tracciato che sia il grafo del codificatore, per dato stato iniziale, si può valutare

la sequenza codificata associata a una qualsiasi sequenza d’ingresso seguendo il

percorso a essa individuato ed annotando le corrispondenti parole d’uscita. Ovviamente

per sequenze molto lunghe, anche questa rappresentazione manifesta i suoi limiti, si

pensi al caso in cui uno stesso lato compaia più volte nell’ambito di una stessa

sequenza.

13.5 - Codici catastrofici

Osserviamo che ogni codificatore convoluzionale, essendo lineare, associa alla

sequenza d’ingresso nulla la sequenza nulla.

Il percorso associato alla sequenza d’ingresso identicamente nulla nel grafo di Fig.E

13.2 consisterebbe nel percorrere infinite volte il ramo che emerge e termina nello stato

zero. I rami che originano e terminano nello stesso stato vengono denominati self loop.

Notiamo che lo stesso codificatore, partendo dallo stato zero, associa alla sequenza

costituita solo da bit , la sequenza come possiamo

notare tale sequenza seppur semi-infinita ha peso ; cioè, nonostante la sequenza di

ingresso considerata sia quella a massima distanza dalla sequenza nulla, le rispettive

sequenze codificate distano tra loro non più di indipendentemente dalla loro

lunghezza. Il codificatore di Fig.E 13.1 è un in realtà un esempio di Codice

catastrofico. Tale denominazione discende dal fatto che da un codificatore ci si aspetta,

quantomeno, che al crescere della distanza di Hamming tra le sequenze d’ingresso

(parliamo si sequenze semi-infinite) cresca anche quella tra le corrispondenti sequenze

codificate. Il motivo per il quale il “nostro” codificatore è catastrofico risiede nella

presenza di un selfloop che associa a una parola d’ingresso di peso non nullo la parola

d’uscita nulla, sicché "ciclando" su questo ramo il peso della sequenza d’uscita non

varia. Il codificatore fin qui utilizzato, malgrado sia catastrofico non perde la sua

valenza che è puramente didattica.

13.6 - Trellis degli stati

I limiti all’utilizzo del grafo per lo studio di un codice convoluzionale, sono

essenzialmente legati al fatto che in questa rappresentazione non compare il tempo.


Premesso che in quel che segue per brevità enumereremo talvolta gli stati con il

numero decimale corrispondente al contenuto della memoria, supponiamo che all’istan-

te iniziale il codificatore si trovi nello stato , da esso all’istante , potranno essere

raggiunti nuovi stati figli e da ciascuno di questi ultimi all’istante ne potranno

essere raggiunti per un totale di stati figli raggiungili all’istante a partire

dallo stato iniziale dopo due parole di ingresso.

Ci rendiamo conto del fatto che all’istante ( ) tutti i possibili stati del

codificatore saranno raggiungibili. Ciò è vero anche in virtù del fatto che, per la

struttura stessa del codificatore, a prescindere dallo stato in cui si trova, a parole d’in-

gresso distinte corrispondono stati di arrivo distinti.

Quanto appena detto può essere rappresentato graficamente mediante il trellis

(letteralmente, ma è “infelice”, graticcio) degli stati del codice. Il trellis associato al

codificatore di Fig.E 13.1 è rappresentato in Fig.E 13.3 Come possiamo notare il trellis

è un albero, che ha origine nello stato in cui si trova il codificatore all’istante iniziale,

che generalmente, ma non necessariamente, è lo stato . Esso costituisce la radice

Fig.E 13.3 – Trellis degli stati del codificatore di Fig.E 13.1


dell’albero, da cui si dipartono i lati associati a tutte le possibili parole di ingresso che

terminano sui vertici raggiungibili all’istante da ciascuno di detti vertici si

dipartiranno ulteriori lati che termineranno su vertici figli al tempo 2 skT .

Al tempo ( ) tutti gli stati vengono raggiunti da un lato ed al passo

successivo la sezione di trellis, cioè l’insieme dei lati compresi tra i vertici relativi a

due istanti di tempo consecutivi, è completa, nel senso che contiene tutti i possibili lati,

tutte le sezioni successive saranno complete, uguali tra loro ed, idealmente, in numero

infinito. Ogni sezione si può etichettare con un numero che esprime la “profondità”

della sezione cioè la collocazione temporale di una data sezione nel trellis.

Seguire l’evoluzione dell’uscita sul trellis

è semplice in quanto nel percorso associato alla

sequenza d’ingresso non vi sono sovrap-

posizioni.

Esempio 13.1

Si Calcoli l’uscita del codice di rate

individuato

dai generatori . In corrispondenza alla

sequenza d’ingresso .

I due generatori rappresentati in binario sono:

e corrispondono allo schema mostrato in Fig.E 13.4.

Il codificatore ha 8 stati, il suo trellis è mostrato in

Fig.E 13.5, nella stessa figura è evidenziato il percorso associato alla sequenza di ingresso ,

la corrispondente sequenza d’uscita è quindi: .

È interessante osservare che un ulteriore zero nella sequenza d’ingresso riporterebbe il

codificatore allo stato zero.

Fig.E 13.4 - schema del codificatore convo-

luzionale rate

Fig.E 13.5 – Trellis del codice convoluzionale rate

Capitolo - 14

L’ALGORITMO DI VITERBI

14.1 - Decodifica hard e soft di un codice convoluzionale.

Occupiamoci adesso della decodifica utilizzando il criterio della massima

verosimiglianza.

Facciamo riferimento per chiarirci le idee allo schema di principio mostrato in

Fig.E 14.1. Esso rappresenta una sorgente binaria che emette una sequenza binaria di

bit, , cui è connesso un codificatore convoluzionale con rate

che produce

una sequenza codificata di bit, , che modula antipodalmente un impulso di

segnalazione ( ) in banda base di durata non maggiore dell’intervallo

assegnato a ogni bit codificato ottenendo il segnale ( ) ∑ ( )

( (

) ).

( ) viene quindi inviato su un canale AWGN che introduce cioè un rumore

gaussiano n t con densità spettrale di potenza bilatera .

Il segnale ( ), in uscita al canale, che perviene al ricevitore, trascurando ritardo

ed attenuazione, sarà quindi ( ) ( ) ( ).

Il ricevitore di figura è costituito da un filtro adattato all’impulso di segnalazione

la cui uscita viene campionata a cadenza , producendo la sequenza , che per le

ipotesi fatte non sarà affetta da interferenza intersimbolica. Avremo cioè

in cui è una variabile aleatoria Gaussiana a media nulla e varianza . Ne

Fig.E 14.1 - schema di principio di un sistema di trasmissione, con codificatore convoluzionale e

modulazione antipodale in banda base - decodificatore hard, ramo superiore, decodificatore soft,

ramo inferiore.


segue che la generica , condizionata all’invio di è la realizzazione di una variabile

aleatoria gaussiana a media e varianza . Inoltre Le condizionate

all’invio di una data saranno mutualmente statisticamente indipendenti.

In Fig.E 14.1 Abbiamo a questo punto indicato due alternative:

la prima (ramo superiore) consiste nell’utilizzare un rivelatore a soglia che fornirebbe

in uscita una sequenza binaria stimata , da dare in “pasto” ad un decodificatore

che in questo caso sarebbe di tipo hard;

la seconda (ramo inferiore in Fig.E 14.1) utilizzare un decodificatore in grado di

utilizzare direttamente la in questo caso il nostro decodificatore sarebbe di tipo

soft.

Indipendentemente dal tipo di decodificatore viene prodotta una sequenza

informativa stimata ottenuta in corrispondenza a una sequenza codificata

, cioè una sequenza che corrisponde ad un percorso sul trellis del codificatore.

Ovviamente non è detto che i due decodificatori producano la stessa .

In quel che segue supporremo di voler decodificare una sequenza di lunghezza

finita. Supporremo anche che il decodificatore hard o soft che sia:

- conosca la struttura del codificatore convoluzionale;

- conosca lo stato iniziale in del codificatore;

- conosca lo stato finale fin del codificatore,

Osserviamo che la conoscenza dello stato finale da parte del decodificatore,

implica che il codificatore abbia provveduto ad aggiungere alla sequenza informativa

un suffisso in grado di condurre il codificatore in uno stato assegnato. Va da se che i

simboli del suffisso non conterranno informazione e comporteranno quindi un peggio-

ramento dell’effettivo rate del codice. Tale peggioramento sarà tanto meno rilevante

quanto più lunghe saranno le sequenze da trasmettere.

In linea di principio la decodifica MV hard della sequenza costituita da

-uple di bit in uscita al rivelatore a soglia è semplice, è, infatti, sufficiente scegliere la

sequenza ammissibile2

che ha la minima distanza di Hamming dalla generata

dal rivelatore, scegliendo eventualmente a caso qualora dovesse esservi più d’una

sequenza ammissibile con lo stesso requisito.

Analogamente la decodifica MV soft consisterebbe nello scegliere, tra le

sequenze ammissibili, quella cui è associata una sequenza che, pensata

come un punto di , ha la minima distanza Euclidea dalla sequenza corri-

2 per sequenza ammissibile intendiamo una sequenza

associabile ad un percorso sul trellis che abbia

inizio in e termini in .

L’Algoritmo di Viterbi 109

spondente al segnale ricevuto, rappresentata nello stesso spazio. Va da se che, in questo

caso, la probabilità che due sequenze ammissibili abbiano la stessa distanza da quella

ricevuta è nulla.

Già questa sola considerazione ci fa intuire che l’impiego della decodifica soft

migliora le prestazioni del sistema in termini di probabilità d’errore.

Al crescere della lunghezza dei messaggi da decodificare, appare chiaro che

l’approccio sopra descritto seppur formalmente corretto diventa improponibile in pra-

tica, sia per la crescita esponenziale del numero di sequenze ammissibili, sia per il

ritardo che un decodificatore siffatto comporterebbe. Sarebbe infatti indispensabile

attendere la ricezione dell’intera sequenza prima che il processo di decodifica possa

avere inizio.

14.2 - L’algoritmo di Viterbi

In questo paragrafo descriveremo un algoritmo di decodifica che, con modifiche

non concettuali, può essere impiegato sia per decodificatori hard che soft dei codici

convoluzionali.

In quel che segue chiameremo:

metrica di ramo la distanza di Hamming, o il quadrato della distanza Euclidea, tra gli

bit

codificati che etichettano il ramo e la porzione di sequenza

ricevuta corrispondente precisamente

(

)

{

∑ ( )

∑ ( ) (

)

(14.2.1)

(ad apice abbiamo indicato la sezione di trellis cui il ramo appartiene ed i pedici,

individuano lo stato di partenza e quello di arrivo del ramo in esame);

percorso una sequenza ininterrotta di rami che origina in in

lunghezza del percorso il numero di rami compongono il percorso

metrica di percorso la somma delle metriche di ramo che compongono il percorso;

cammino una sequenza ininterrotta di rami del tipo

lunghezza del cammino il numero di rami compongono il cammino

metrica di cammino la somma delle metriche dei rami che lo compongono;

Abbiamo detto che il decodificatore conosce lo stato iniziale in cui si trova il

codificatore all’arrivo di una sequenza informativa, supponiamo sia lo stato zero. Al

primo passo, osservando la sequenza ricevuta, il decodificatore può etichettare ciascuno


dei rami del trellis che emergono dallo stato iniziale, con la metrica ad essi

associata, calcolata mediante la prima o la seconda delle (14.2.1), a seconda che la

decodifica sia di tipo hard o soft rispettivamente. Il decodificatore provvederà anche ad

etichettare gli stati raggiunti con le metriche dei percorsi che vi pervengono. Le

metriche di percorso in questo caso coincidono banalmente con quelle del singolo ramo

che compone i percorsi cui si riferiscono. Agli stati raggiunti verrà associata anche la

sequenza informativa associata al relativo percorso.

Al secondo passo da ciascuno dei stati raggiunti emergeranno rami, a cia-

scuno di essi si può associare una metrica di ramo come al passo precedente. Ad ogni

stato in cui termina un ramo assoceremo:

- una metrica di percorso ottenuta sommando alla metrica del ramo che termina

nello stato in parola quella di percorso associata allo stato da cui il ramo emergeva;

- una sequenza informativa di percorso ottenuta giustapponendo a quella associata

allo stato di partenza quella del ramo.

Potremo continuare ad addentrarci nel trellis seguendo questa logica fino al passo

, in quanto fino a tale passo ogni stato viene raggiunto al più da un percorso.

Al - esimo passo potremo ancora associare a ogni ramo la sua metrica, ma per

associare le metriche di percorso agli stati sorgerà un problema. Esistono infatti

percorsi distinti che terminano in ciascuno stato.

Se consideriamo un cammino nel trellis di lunghezza che abbia origine in

uno stato in cui confluiscano percorsi di lunghezza , giustapponendo il cammino a

ciascun percorso di lunghezza otterremmo percorsi ammissibili di lunghezza

. La metrica di ciasuno di essi sarà data dalla somma della metrica di uno dei

percorsi di lunghezza più la metrica del cammino. Tra i percorsi così ottenuti quello

che avrà la metrica minore sarà evidentemente ottenuto a partire dal percorso di

lunghezza che aveva la metrica minore. Ne segue che se più percorsi confluiscono in

uno stesso stato ha senso memorizzare solo quello che ha la metrica minore.

Osserviamo che nel caso in cui la metrica fosse quella di Hamming (decodifica

hard) potrebbe darsi che più di un percorso abbia minima metrica, il decodificatore in

questa eventualità dovrebbe scegliere a caso.

Dal - esimo passo in poi il decodificatore memorizzerà per ogni stato solo la

metrica e la sequenza informativa associata al “miglior” percorso che vi confluisce.

Fa eccezione solo l’ultimo passo, in questo caso il decodificatore conoscendo lo

stato di arrivo si limiterà a considerare solo i percorsi che vi confluiscono scegliendo

il migliore tra essi (quello che ha accumulato la metrica minore).

L’Algoritmo di Viterbi 111

Abbiamo appena descritto l’algoritmo di Viterbi.

14.3 - Efficienza dell’algoritmo di Viterbi

Appare evidente la riduzione di complessità di questo algoritmo rispetto alla

ricerca esaustiva teorizzata nel paragrafo precedente. Ad ogni passo di decodifica, a

parte il transitorio iniziale, dovremo infatti calcolare metriche di ramo per ciascuno

dei ( ) stati iniziali della sezione di trellis e utilizzarle per calcolare le metriche di

percorsi. Di questi ultimi solo ( ) verranno memorizzati per utilizzarli al passo

successivo. Ne segue che la complessità dell’algoritmo cresce solo linearmente con la

lunghezza della sequenza informativa, a differenza della ricerca esaustiva che invece

crescerebbe esponenzialmente. Va comunque sottolineato che la complessità dell’algo-

ritmo di Viterbi cresce esponenzialmente con la lunghezza di vincolo del codificatore.

Un altro vantaggio nell’utilizzo dell’algoritmo di Viterbi consiste nel fatto che

dopo un certo numero di passi di decodifica che dipende dalla lunghezza di vincolo

(tipicamente una decina di lunghezze di vincolo) tutti i percorsi “sopravvissuti” fini-

scono con l’avere una parte iniziale in comune. Ciò limita sia la latenza sia il fabbi-

sogno di memoria del decodificatore.

Capitolo - 15

PRESTAZIONI DEI CODICI CONVOLUZIONALI

15.1 - Funzione di trasferimento di un codificatore convoluzionale.

I codici convoluzionali sono come abbiamo già detto lineari, nel senso che la

somma di due sequenze codificate è ancora una sequenza codificata, esattamente quella

che si otterrebbe codificando la somma delle due sequenze informative.

Ciò significa che possiamo valutare le prestazioni del codice in termini di

probabilità d’errore ammettendo che venga inviata la sequenza nulla e valutare la pro-

babilità che per effetto del canale venga rivelata dal decodificatore una sequenza am-

missibile diversa.

Per i nostri scopi è utile definire alcune grandezze associate al codificatore. La

prima è la cosiddetta distanza colonna ( ) essa è un’applicazione che associa ad

ogni livello di profondità del trellis del codice la minima distanza di Hamming

ottenibile dalla sequenza nulla prendendo in considerazione tutte le possibili sequenze

d’ingresso cui corrispondono percorsi sul trellis che si discostano da quello relativo alla

sequenza nulla a partire dall’istante iniziale. Il limite di ( ) per si chiama

distanza libera, , del codice. Il percorso cui corrisponde la distanza libera non è

necessariamente unico, ma certamente salvo il caso in cui il codice sia catastrofico è un

percorso che si discosta dalla sequenza nulla per poi ricongiungersi ad essa.

Sia la distanza colonna che la distanza libera possono in teoria essere calcolate

per ispezione diretta sul trellis del codice, ma è anche possibile ottenere la distanza

libera e molte altre informazioni sul codice procedendo in modo diverso.

Ci proponiamo in particolare di raccogliere informazioni sul numero di percorsi che

hanno origine e termine nello stato zero diversi da quello che da esso non si discosta

mai.

Per farlo consideriamo il

diagramma degli stati del

codificatore e sopprimiamo il

self loop associato allo stato

zero sdoppiamo quindi lo stato

zero in due stati uno, sorgente, da cui fuoriescono i rami ed uno, pozzo con solo rami

entranti come in Fig.E 15.1. Nella stessa figura si può notare anche che i rami del grafo

sono stati etichettati con dei trinomi l’indeterminata vi compare sempre con grado ,

Fig.E 15.1 – Grafo modificato del Codice rate

114 Capitolo - 15

la sua funzione è in realtà solo quella di tener conto del passaggio attraverso il ramo, il

grado di esprime il peso della parola informativa associata al ramo esso è quindi

compreso tra e , il grado di esprime il peso della parola di codice associata al

ramo, e non può quindi essere maggiore di .

Basandoci sulla teoria dei grafi orientati e pesati possiamo ricavare la funzione di

trasferimento tra il nodo sorgente ed il nodo pozzo.

Per farlo si può procedere in due modi, il più semplice consiste nello scrivere il

sistema lineare di equazioni che il grafo rappresenta. Ciò si ottiene associando a ogni

nodo un’incognita del sistema.

In corrispondenza a ciascun nodo possiamo scrivere un’equazione che, detta

l’incognita associata al nodo -esimo e la trasferenza associata al ramo che emerge

dal nodo -esimo e converge in quello -esimo, sarà del tipo:

∑

( )

(15.1.1)

Osserviamo che l’equazione associata al ramo sorgente si riduce ad un’identità

essendo quest’ultimo privo di rami entranti. A titolo d’esempio, denominando rispet-

tivamente inV e outV le variabili associate al nodo sorgente ed al nodo pozzo in cui

abbiamo sdoppiato lo stato 0 , scriviamo le equazioni associate al grafo di Fig.E 15.1:

{

(15.1.2)

Possiamo quindi procedere all’eliminazione di tutte le variabili ad eccezione

delle e . Utilizzando ad esempio le prime tre equazioni otteniamo:

{

(15.1.3)

quindi, procedendo in modo analogo, dopo qualche passaggio otteniamo:

Prestazioni dei Codici Convoluzionali 115

( )

(15.1.4)

la ( ) prende il nome di funzione di trasferimento del codice.

Se con la tecnica della divisione lunga espandiamo la (15.1.4), pensando il

numeratore e il denominatore come polinomi nell’indeterminata , possiamo ancora

scrivere:

( ) ( ) (

) ( )

(

)

(15.1.5)

dal coefficiente della potenza più piccola di a secondo membro della precedente,

desumiamo che vi è un cammino con peso d’ingresso che si discosta dallo stato e

che torna ad esso dopo rami accumulando un peso d’uscita pari a . Ne segue che la

distanza libera del codice in parola sarà esattamente . Osservando il coefficiente

della potenza di immediatamente superiore scopriamo che esistono anche tre percorsi

con peso d’uscita , di cui: uno di lunghezza e peso d’ingresso ; il secondo di

lunghezza e peso d’ingresso ; il terzo di lunghezza con peso d’ingresso .

Qualora fossimo interessati solo al peso delle sequenze codificate che si

discostano dalla sequenza nulla per poi ricongiungersi con essa, potremmo porre nella

(15.1.4) o nella (15.1.5) e , ottenendo

( ) (15.1.6)

In generale la funzione di trasferimento di un codice convoluzionale può essere

espressa nella forma:

( ) ∑ ∑ ∑ ( )

(15.1.7)

dove ( , , ) esprime il numero di cammini di peso , con peso della sequenza

d’ingresso che emergono dallo stato zero per poi farvi ritorno dopo rami.

Dalla precedente, eguagliando ad le variabili che non ci interessano e somman-

do rispetto ai rispettivi indici, otteniamo delle funzioni di trasferimento semplificate, ad

esempio ponendo e nella (15.1.7) otteniamo

( ) ( ) ∑ ∑ ∑ ( )

∑ ( )

(15.1.8)

dove ( ) ∑ ∑ ( )

.

116 Capitolo - 15

15.2 - Bound sulla probabilità di primo evento d’errore.

Per analizzare le prestazioni di un codice convoluzionale si fa riferimento, oltre

che alla probabilità d’errore sul bit informativo anche alla cosiddetta probabilità di

primo evento d’errore, o anche probabilità d’errore di nodo. Essa esprime la probabilità

che in un certo istante la sequenza stimata si discosti da quella effettivamente trasmessa

per poi ricongiungersi con essa.

Possiamo assumere ai fini del calcolo che la sequenza trasmessa sia

quella identicamente nulla, indicheremo con tale sequenza che corrisponde al

percorso semiinfinito sul trellis che non si discosta mai dallo stato . Possiamo fare tale

ipotesi in virtù della linearità del codificatore e del fatto che la decodifica è a massima

verosimiglianza.

Sappiamo che il decodificatore opera le sue scelte basandosi sulla sequenza

binaria prodotta dal rivelatore a soglia nel caso di decodifica hard, ovvero sulla

sequenza reale dei campioni in uscita al filtro adattato per decodifica soft.

Ammettiamo che fino alla profondità nel trellis il decodificatore abbia

attribuito al percorso la metrica minore e che al passo successivo abbia inizio un

cammino ( )

( ) che si discosta dallo stato per ritornarvi dopo sezioni di

trellis. Alla profondità il decodificatore lascerà sopravvivere un solo percorso tra

quelli che pervengono allo stato se il percorso , coincidente con fino alla

profondità nel trellis e con da fino alla sezione , avrà accumulato la

metrica minore di , quest’ultimo verrà scartato. è un possibile primo evento

d’errore. Va da sé che vi è un’infinità numerabile di possibili primi eventi d’errore, cioè

tutti i cammini che si discostano dallo stato zero per poi ricongiungersi ad esso.

Purtroppo il calcolo esatto della probabilità di primo evento d’errore è imprati-

cabile, possiamo tuttavia maggiorare la probabilità cercata, basandoci sull’union bound.

Detto il cammino coincidente con tra le sezioni e

Osserviamo che la scelta del decodificatore sarà determinata soltanto dalle metrica

accumulata dai cammini e , in quanto fino al passo i due percorsi coincidevano

quindi condividevano la stessa metrica.

Per applicare l’union bound dobbiamo valutare in corrispondenza a ciascun

primo evento d’errore la probabilità che esso si manifesti nell’ipotesi che il

decodificatore possa scegliere solo tra il percorso corretto e quello relativo all’evento

d’errore in parola.


Ciò, detto in altri termini, equivale a calcolare la probabilità che, a causa del

rumore introdotto dal canale BSC, la porzione di sequenza ( ) in uscita al

rivelatore a soglia, per il decodificatore hard (la porzione ( ) di campioni in

uscita al filtro adattato per quello soft) corrispondente alle sezioni del trellis che

contengono i due cammini e , , appartenga alla regione di decisione di

malgrado sia stata inviata la sequenza identicamente nulla, corrispondente a

Ci si convince facilmente che la somma di tutte le probabilità appena descritte

maggiora la probabilità d’errore di nodo, in quanto quest’ultima rappresenta la

probabilità dell’evento unione tra tutti quelli associati ai possibili primi eventi d’errore

sopra descritti.

Detto

il complementare della regione di decisione del cammino corretto

nell’ipotesi che il decisore sia chiamato a scegliere tra e , possiamo scrivere:

∑ (

( )

( )

)

(15.2.1)

Nel caso di decodifica hard, è opportuno osservare che ai fini del calcolo della

probabilità che compare ad argomento della sommatoria nella (15.2.1), non

contribuiscono i bit codificati di uguali a quelli di (cioè i bit nulli di ), in

quanto quale che sia il corrispondente bit della sequenza ricevuta esso apporterebbe un

eguale contributo alle distanze di ( ) da entrambi i cammini e

.

Indichiamo adesso con ( ) il peso del cammino . Osserviamo che se ( ) è

dispari, posto ⌊ ( )

⌋ , il decodificatore sceglierà il cammino ogniqualvolta

risulti:

( ( )

) (15.2.2)

La probabilità che ciò accada, condizionata all’invio della sequenza nulla è data da:

( ( )

( ) )

( ( ( )

) ( )

)

∑ ( ( )

) ( ) ( )

( )

(15.2.3)

dove ( ) indica il cammino stimato e indica la probabilità di crossover del

BSC con cui può essere schematizzata la parte inclusa nel poligono tratteggiato in rosso

del sistema di trasmissione mostrato in Fig.E 14.1.

118 Capitolo - 15

Se il peso di è pari esisteranno ( ( ) ( )

) possibili sequenze ricevute ( )

che hanno eguale distanza da e . In tale eventualità il decodificatore sceglierebbe

in modo puramente casuale tra e . La probabilità che venga scelto il cammino

sarà in questo caso espressa dalla:

( ( )

( ) )

( (

( ) ) ( )

( ) )

(( ( ( )

)) ( )

)

(

( ) ( )

) ( ) ( )

∑ ( ( )

) ( ) ( )

( )

⌊ ( )

⌋

(15.2.4)

Esempio 15.1

La probabilità di crossover del BSC con cui può essere schematizzata la parte inclusa nel

poligono tratteggiato in rosso del sistema di trasmissione mostrato in Fig.E 14.1, assumendo che al

bit codificato competa un’energia

e che il rumore gaussiano abbia una densità

spettrale di potenza monolatera , sarà espressa dalla probabilità che il campione in uscita al

filtro adattato per effetto del rumore sia minore di zero, malgrado il bit codificato fosse un uno, o

indifferentemente, dalla probabilità che il succitato campione, per lo stesso motivo, sia maggiore di

zero malgrado il bit codificato inviato fosse uno zero. Nel caso in cui il bit trasmesso sia un uno

avremo

( ) ∫

√

( )

√

√ ∫

√

(

√ ) (

√ )

Tenuto conto delle ipotesi fatte sull’energia del bit codificato, se vogliamo fare comparire nella

precedente il rapporto tra l’energia associata al bit informativo e la densità spettrale monolatera di

rumore possiamo scrivere:

√ √

Da cui:

(√

)

Osserviamo che la (15.2.3) e la (15.2.4), dipendono solo dal peso di non dal

numero di rami da cui esso è costituito. In altri termini, tutti gli eventi d’errore di

uguale peso avranno la stessa probabilità di essere erroneamente scelti dal decodi-

ficatore indipendentemente dal numero di rami in essi contenuti. Sulla base di que-

st’ultima osservazione possiamo compattare in un'unica espressione la (15.2.3) e la

(15.2.4), indicando semplicemente con un evento d’errore di peso , ottenendo:

( )

( )

(

⌊

⌋) ( )

∑ ( ) ( )

(15.2.5)


Osserviamo adesso che la probabilità di primo evento di errore di peso

condizionata all’invio di una qualunque sequenza è uguale a quella condizionata

all’invio della sequenza nulla. Ne segue che, se tutti i percorsi sul trellis sono equi

probabili, la probabilità di errore di nodo di peso è uguale alla probabilità di errore di

nodo condizionata all’invio della sequenza nulla:

( ) ( ) (15.2.6)

La (15.2.5) ci suggerisce di riordinare la (15.2.1) accorpando tutti gli eventi d’errore di

ugual peso. Il numero di tali eventi può essere dedotto dalla ( ) del codice. Tenendo

conto della (15.1.8) e della (15.2.6) possiamo quindi scrivere:

∑ (

( )

( )

)

∑ ( )

( )

(15.2.7)

Nel caso di decodifica soft, basandoci sullo schema di Fig.E 14.1 e assumendo che

l’impulso di segnalazione abbia energia sE , potremo scrivere:

∑ ( (

( ) {√ ( ( )

)}

( ))

( ( ) { √ }

( ))

( ) )

∑

(

√∑ ( √

( ))

( )

√

)

∑ (√ ( )

)

(15.2.8)

che può essere anche riformulata in termini dell’energia per bit informativo, ponendo

cioè , dove è il rate del codice e della densità spettrale di potenza

monolatera ottenendo:

∑ (√ ( )

)

(15.2.9)

Osserviamo che anche gli argomenti delle ( ) a secondo membro della

precedente non dipendono dalla lunghezza di , ma solo dal suo peso. La som-

matoria a secondo membro della precedente può quindi, anche in questo caso, essere

riordinata accorpando tutti gli eventi di errore di egual peso, ottenendo:

∑ ( ) (√

)

(15.2.10)

120 Capitolo - 15

La precedente, a fronte di un’ulteriore maggiorazione può assumere una forma più

semplice da calcolare. Ricordando infatti che vedi , per argomento non negativo, vale la

disuguaglianza ( )

(vedi (5.9.14), possiamo ancora scrivere:

( ) (√

)

(

)

(15.2.11)

per mezzo della quale otteniamo:

∑ ( ) (√

)

∑ ( )

( )|

(15.2.12)

Anche nel caso della decodifica Hard possiamo maggiorare ulteriormente la

ricordando la maggiorazione di Bhattacharyya (5.9.10) che ci permette di

scrivere:

( ) ( )

(15.2.13)

Quest’ultima ci permette, partendo dalla (15.2.7) di scrivere:

∑ ( )

( ) ∑ ( )

( )

( ) (15.2.14)

La (15.2.12) e la (15.2.14) possono essere calcolate facilmente, disponendo della

( ) del codice, la (15.2.7) e la (15.2.10) sono dei bound più stretti, ma possono essere

calcolati solo in modo approssimato, entrambe tuttavia sono in genere dominate dal

primo addendo della sommatoria che corrisponde alla distanza libera del codice. Il

primo addendo di ciascuna di esse rappresenta in genere già da solo una maggiorazione

della probabilità d’errore di nodo.

15.3 - Bound sulla probabilità d’errore sul bit informativo.

Al fine di calcolare la probabilità d’errore sul bit d’informazione ,

consideriamo una porzione di sequenza codificata costituita da bit con

(l’apice ha la sola funzione di etichetta). Nella corrispondente porzione di

sequenza decodificata costituita da bit saranno presenti un certo numero di

bit errati. Osserviamo che la presenza di bit errati è possibile solo se nella si

sono manifestati errori di nodo. Sappiamo anche che a ogni evento d’errore di nodo

corrisponde un ben preciso numero di bit informativi errati.

Indichiamo adesso con

la frequenza relativa d’errore sul bit, della sequenza

-esima. Essa è espressa dal rapporto tra il numero di bit informativi errati e di quelli

inviati. Osserviamo che il numero totale di bit informativi errati può essere calcolato


anche accorpando tutti gli eventi d’errore di nodo caratterizzati da uno stesso numero di

bit informativi errati. A Indicando con ( ) il numero di eventi d’errore che

contengono esattamente bit informativi errati manifestatisi nella -esima

realizzazione dell’esperimento, possiamo scrivere:

∑ ( )

(15.3.1)

La probabilità d’errore sul bit informativo si può ottenere mediando su un

numero idealmente infinito di repliche dello stesso esperimento come segue:

∑

(15.3.2)

sostituendo la (15.3.1) nella precedente abbiamo:

∑

∑ ( )

∑

∑

( )

(15.3.3)

nella quale, prima di invertire l’ordine delle sommatorie, si è tenuto conto del fatto che

al crescere della lunghezza della sequenza si possono manifestare eventi d’errore con

un numero arbitrariamente grande di bit informativi errati. Si constata facilmente che il

limite all’interno della sommatoria di indice ad ultimo membro della precedente

esprime la probabilità che si manifesti un qualsiasi evento d’errore di nodo che

contenga esattamente bit informativi errati.

Indicando con l’insieme di tutti gli eventi d’errore con bit informativi errati

possiamo scrivere:

( )

∑

( )

(15.3.4)

la precedente può essere maggiorata applicando, come nel paragrafo precedente,

l’union bound:

( ) ∑ ( )

(15.3.5)

A partire dalla (15.3.3) possiamo ancora scrivere:

∑ ( )

∑ ∑ ( )

(15.3.6)

Ricordando la (15.1.7) che per comodità riscriviamo:

( ) ∑ ∑ ∑ ( )

(15.3.7)

122 Capitolo - 15

e tenuto conto che, indipendentemente dal tipo di decodificatore, la probabilità che si

presenti un dato errore di nodo dipende solo dal suo peso possiamo ancora scrivere:

∑ ∑ ( )

∑ ∑ ∑ ( ) ( )

∑ ∑ ( ) ( )

(15.3.8)

La precedente può essere ulteriormente maggiorata applicando la (15.2.14) nel caso di

decodifica hard o la (15.2.12) in quella soft ottenendo rispettivamente:

∑ ∑ ( ) ( )

∑ ∑ ( )

(15.3.9)

∑ ∑ ( ) (

)

(15.3.10)

Osserviamo adesso che risulta:

( )

|

∑ ∑ ∑ ( )

|

∑ ∑ ∑ ( )

∑ ∑ ( )

(15.3.11)

la quale ci permette di riscrivere la (15.3.9) e la (15.3.10) rispettivamente nella forma

più compatta:

( )

|

(15.3.12)

e

( )

|

(15.3.13)

Capitolo - 16

ANELLI DI POLINOMI

16.1 - Premessa

Abbiamo già fornito la definizione di campo e abbiamo anche operato nel campo

costituito da due soli elementi. Si possono costruire anche campi finiti (Campi di

Galois Galois Field) con un numero d’elementi che sia un primo o una potenza di

un primo.

Nel caso in cui il

campo abbia un numero pri-

mo d’elementi, l’addizione

e la moltiplicazione tra ele-

menti del campo si possono

effettuare in modo tradizio-

nale avendo cura di ridurre il

risultato modulo .

Nella Tabella 16.1 a titolo d’esempio sono riportati i risultati di tutte le possibili

somme e prodotti tra coppie d’elementi di 7, il campo di Galois con sette elementi.

16.2 - L’anello polinomi a coefficienti in

Consideriamo un campo e un’indeterminata , indichiamo con l’insieme

di tutti i possibili polinomi (cioè di qualunque grado) nella variabile con coefficienti

appartenenti ad , il generico elemento di sarà cioè del tipo:

( )( ) (16.2.1)

dove è un intero non negativo qualsiasi e , essendo l’elemento neutro

rispetto all’addizione in . Conveniamo inoltre:

a) di utilizzare per le leggi di composizione del campo i simboli utilizzati per il campo

reale

b) di indicare con ( )( ) il polinomio identicamente nullo, cioè coincidente con

c) di omettere l’apice tra parentesi per indicare un polinomio di grado qualsiasi;

d) che dato ( )( ), per .

Siano ( )( ) ( )( ) due elementi di e un elemento di , poniamo:

( ) ( ) ( ) ( )

( )

(16.2.2)

𝔾𝔽7

0 1 2 3 4 5 6 ⊗ 0 1 2 3 4 5 6

0 0 1 2 3 4 5 6 0 0 0 0 0 0 0 0

1 1 2 3 4 5 6 0 1 0 1 2 3 4 5 6

2 2 3 4 5 6 0 1 2 0 2 4 6 1 3 5

3 3 4 5 6 0 1 2 3 0 3 6 2 5 1 4

4 4 5 6 0 1 2 3 4 0 4 1 5 2 6 3

5 5 6 0 1 2 3 4 5 0 5 3 1 6 4 2

6 6 0 1 2 3 4 5 6 0 6 5 4 3 2 1

Tabella 16.1 - Campo di Galois di 7 elementi


( )( ) ( )( ) ( )( )

(16.2.3)

e

( )( ) ( )( ) ( )( )

∑

(16.2.4)

Nella precedente, la sommatoria va calcolata secondo le regole di , come pure il

prodotto al suo interno.

In sostanza abbiamo appena introdotto in l’addizione e la moltiplicazione.

Rispetto all’addizione è facile verificare che è un gruppo commutativo, inoltre la

moltiplicazione tra polinomi in è commutativa e distributiva rispetto all’addizione.

è pertanto un anello commutativo, con identità, che, ovviamente, coincide con

l’identità del campo , che indicheremo con .

Osserviamo che il prodotto tra polinomi non nulli è non nullo. Il polinomio nullo

si ottiene se e solo se almeno uno dei due moltiplicandi è il polinomio nullo. Vale cioè

anche la legge di annullamento del prodotto.

Quanto detto comporta tra l'altro che i polinomi sono

linearmente indipendenti su .

16.3 - Spazi di polinomi

Consideriamo adesso il sottoinsieme ( )

di costituito da tutti i

polinomi di grado minore di . La somma di due elementi di ( )

è ancora un

elemento di ( )

. Inoltre moltiplicando un qualunque elemento di ( )

per

un elemento di , che coincide con ( )

, otteniamo ancora un elemento di

( )

.

( )

è quindi uno spazio vettoriale su . La sua dimensione è in quanto

generabile tramite i suoi elementi linearmente indipendenti .

Ci si convince facilmente che detto spazio vettoriale è isomorfo allo spazio

costituito da tutte le -uple ordinate di elementi di , basta infatti associare al

polinomio ( )( ) ( )

, l’elemento a se ,

ovvero l’elemento se

Capitolo - 17

CODICI POLINOMIALI

Dati due interi e , scegliamo un polinomio ( )( ) che

chiameremo polinomio generatore, tramite ( )( ) possiamo individuare il sottoin-

sieme ( )

che contiene i polinomi che si ottengono da tutti i possibili

prodotti tra ( )( ) e i polinomi ( ) ( )

.

Consideriamo adesso due elementi ( ) e ( ) appartenenti a , quindi

esprimibili rispettivamente nella forma:

( ) ( ) ( )( ) ( ) ( ) ( )( ) (17.1.1)

Comunque scelti risulta:

( ) ( ) ( ( ) ( )) ( )( ) (17.1.2)

La precedente ci mostra che ( ) è un sottospazio di ( )

, quindi ne è anche un

sottogruppo.

Il corrispondente sottoinsieme di è quindi un codice di gruppo.

Abbiamo già detto (vedi § 8.2 - ) che la distanza di Hamming tra parole di è

una metrica, la distanza minima di è data dalla sua parola di peso minimo cioè dalla

parola che ha il minor numero di lettere diverse da , che non è necessariamente unica.

Ci si convince anche facilmente del fatto che se s’intende impiegare un codice

polinomiale per la rilevazione d’errore è sufficiente dividere il polinomio corri-

spondente alla parola ricevuta per il polinomio generatore e verificare che il resto di

tale divisione sia il polinomio nullo, per essere certi che la parola ricevuta appartiene al

codice.

Consideriamo adesso il caso dei codici polinomiali sul campo essi sono

certamente codici binari a blocchi, nel senso che ammettono una matrice generatrice

che si può facilmente costruire a partire da ( )( ). Come righe di tale matrice si

possono scegliere infatti le stringhe dei coefficienti dei polinomi di codice ottenuti

moltiplicando il polinomio generatore per i polinomi . Viceversa non

è vero in generale che i codici lineari a blocchi siano polinomiali, al fine di verificare se

un codice lineare a blocchi è polinomiale è sufficiente verificare che tutti i polinomi

associati alle righe della matrice generatrice ammettano un fattore comune di grado

.

Capitolo - 18

IDEALI DI UN ANELLO DI POLINOMI

18.1 - Premessa

Torniamo adesso a parlare di campi finiti, abbiamo visto come si possono

costruire campi finiti con un numero primo d’elementi; è anche possibile, come

mostreremo più avanti, definire campi che hanno un numero di elementi che è una

potenza (ad esponente intero) di un numero primo. Il generico elemento di un tale

campo si può quindi mettere in corrispondenza biunivoca con l’insieme

( ) , che

ha la stessa cardinalità.

Sorge quindi spontaneo indagare sulla possibilità di individuare in

( ) due

opportune leggi di composizione tra suoi elementi che consentano di pensare a

( ) come ad un campo di elementi. Sarebbe a questo punto possibile definire

degli isomorfismi tra

( ) e . Parliamo di isomorfismi perché potrebbero

esistere più leggi di composizione interna che soddisfano le condizioni necessarie per

interpretare

( ) come campo.

Abbiamo già visto che ( )

è un gruppo commutativo rispetto all’addizione

tra polinomi, purtroppo non possiamo dire lo stesso della moltiplicazione tra polinomi

non foss’altro perché ( )

non è chiuso rispetto ad essa.

È quindi necessario definire una legge di composizione interna per ( )

che

abbia tutte le proprietà di cui deve godere la moltiplicazione tra elementi di un campo.

A tal fine è necessaria una piccola digressione di carattere generale.

18.2 - Ideali di un anello con identità.

Consideriamo un anello commutativo con identità diciamo che un suo

sottogruppo è un ideale se:

⊗ (18.2.1)

Qualora l’anello non fosse commutativo dovremmo distinguere tra ideale sinistro e

ideale destro, che potrebbero anche coincidere, nel qual caso si tratterebbe di un ideale

bilaterale.


Abbiamo detto che un ideale è un sottogruppo di , quindi definisce un gruppo

quoziente ⁄ , i cui elementi sono l’ideale stesso, che ne costituisce l’elemento neutro,

e tutti i suoi laterali in , che indicheremo con . Con questa notazione risulta:

( )

⊗ ( ⊗ ) (18.2.2)

Osserviamo che le precedenti sono indipendenti dalla scelta dei rappresentanti di

laterale. Si può anche verificare che ⁄ è come un anello commutativo con identità

detto anello quoziente di rispetto a . Dalla seconda delle (18.2.2) si deduce

facilmente che l’identità moltiplicativa è il laterale che si può indicare con , cioè

quello che contiene l’identità moltiplicativa di

Osserviamo che comunque scelto un elemento di , l’insieme ⊗

è un ideale, infatti ( ⊗ ) ( ⊗ ) ⊗ ( ) , inoltre indicando con

, l’opposto di , ⊗ ( ) e risulta ( ⊗ ) ⊗ ( ) ⊗ ( ( )) ,

pertanto è un sottogruppo di . Ogni ideale generato da un elemento di è detto

ideale principale.

Vale il seguente teorema:

Teorema 18.1

Tutti gli ideali dell’anello dei polinomi su un campo sono principali.

Dimostrazione:

Osserviamo innanzitutto che ( )( ) è un ideale principale per l’anello

commutativo con identità . Consideriamo adesso un ideale di diverso da

( )( ) , in esso scegliamo un elemento ( )( ) di grado minimo. Comunque

scelto un polinomio ( )( ) potremo scrivere:

( )( ) ( )( ) ( )( ) ( )( ) (18.2.3)

dove se (cioè ( )( ) non è un divisore di ( )( )) risulterà ,

ma in questo caso potremmo scrivere:

( )( ) ( )( ) ( )( ) ( )( ) (18.2.4)

che è un assurdo in quanto ( )( ) deve appartenere ad , come mostra la precedente,

pur avendo grado che per ipotesi è il grado minimo dei polinomi non nulli

contenuti in . Deve pertanto essere , o, che è lo stesso, ( )( ) ( )( )

, pertanto ogni ideale di è principale.

***********

Ideali di un Anello di Polinomi 129

Ci si convince facilmente che comunque scelto , anche il polinomio

⊗ ( )( ) genera lo stesso ideale. Ovviamente sarà sempre possibile individuare tra i

generatori di un ideale un solo polinomio monico cioè con il coefficiente del ter-

mine di massimo grado pari ad .


Teorema 18.2

Dati due ideali di , siano ( ) ed ( ) , risulta se e solo se

( ) ha ( ) tra i suoi fattori.

***********

Dato un ideale ( )( ) e un polinomio ( )( ), sappiamo che esistono ( )( )

e ( )( ) tali che si può scrivere:

( )( ) ( )( ) ( )( ) ( )( )

∪ {

(18.2.5)

che ci permette di affermare che ( )( )ed ( )( ) appartengono allo stesso laterale di

( )( )

( )( ) ( )( ) ( )( ) ( )( ) (18.2.6)

Ciascun laterale di un ideale contiene un unico polinomio di grado minimo,

grado che, in virtù della (18.2.5), deve essere minore di . Per convincersene è

sufficiente ricordare che due elementi di un gruppo appartengono allo stesso laterale se

e solo se la loro differenza appartiene al sottogruppo, ma la differenza tra due polinomi

distinti di grado minore non potrà appartenere all’ideale che essendo principale

contiene solo polinomi di grado maggiore od uguale ad , fatta eccezione per il

polinomio nullo, che peraltro è l’unico polinomio di grado minimo contenuto

nell’ideale pensato come laterale di se stesso.

Esiste quindi un isomorfismo “naturale” tra l’anello ( )( ) e l’insieme

( )

dei polinomi a coefficienti in di grado minore di . si può quindi pensare a

( )

come ad un anello commutativo con identità assumendo come risultato della

moltiplicazione tra due polinomi di ( )

il resto della divisione tra l’usuale pro-

dotto dei due polinomi e ( )( ).

Capitolo - 19

CODICI CICLICI

19.1 - Rappresentazione polinomiale di un codice ciclico.

Definizione 19.1

Un codice lineare a blocchi si dice ciclico se e solo se comunque scelta una

sua parola di codice

(19.1.1)

***********

In quel che segue mostreremo che i codici ciclici sono polinomiali. Dovremo in

altri termini mostrare che se un codice è ciclico allora la sua rappresentazione

polinomiale ammette un polinomio generatore.

Ad ogni parola di codice possiamo associare un polinomio appartenente a

( )

come segue:

( )

(19.1.2)

denoteremo con ( ) l’insieme dei polinomi associati alle parole di codice.

Risulta:

( )

(19.1.3)

Notiamo che per trasformare ( ) in ( ) occorrerebbe sottrarre a ( ) il

polinomio . Risulta:

( ) ( )

( ) (19.1.4)

ma è il quoto della divisione tra ( ) e , dalla (19.1.4) si deduce quindi

che ( ) altro non è se non il resto della divisione appena citata.

In altri termini, l’operazione corrispondente alla rotazione ciclica di una parola in

equivale, nel linguaggio dei polinomi, a considerare il resto della divisione per

del prodotto tra il polinomio corrispondente alla parola ed . In simboli:

( ) ( ) ( ) (19.1.5)

19.2 - L’anello

Notiamo che l’insieme dei polinomi di codice ( ) essendo costituito da

polinomi appartenenti a ( )

costituisce anche un sottoinsieme dei coset leader

(intesi come i polinomi di grado minimo) dei laterali di .

Osserviamo inoltre che:


a) avendo supposto che il codice sia lineare, esso deve avere la struttura di

spazio vettoriale sul campo , quindi la sua rappresentazione in forma polinomiale

( ) deve essere anche un sottospazio di ;

b) l’anello ha la struttura di spazio vettoriale sul campo ;

c) esiste un isomorfismo naturale tra ( )

ed , quello che associa

ad ogni polinomio di ( )

l’unico laterale che lo contiene in .

Dalle considerazioni appena fatte discende facilmente che l’immagine, ( ) ,

secondo l’isomorfismo sopra citato di ( ) in è a sua volta un sotto-

spazio vettoriale, quindi anche un sottogruppo, ( ) di , i cui ele-

menti sono i laterali di che contengono i polinomi di codice.

Osserviamo che la ciclicità e la linearità del codice implicano:

( ) ( ) ( ) ( ) ( ) (19.2.1)

dalla quale sempre in virtù della linearità di ( ) discende anche facilmente:

( ) ( ) ( ) ( ) ( ) ( ) ( ) (19.2.2)

Quest’ultima, sulla base dell’osservazione c), può essere rivisitata in termini di laterali

di , infatti ( ) possiamo scrivere:

( ) ( ) { ( ) ( ) ( ) }

( ) ( ) ( )

( ) ⊗ ( ) ( )

( )

⁄

(19.2.3)

La precedente ci permette di affermare che se il codice è ciclico allora ( ) è un

ideale dell’anello .

Viceversa consideriamo un ideale di comunque preso un suo

elemento, sia ( ) , il fatto che sia un ideale implica che:

( ) ⊗ ( ) ( ) ( ) ( ) ( ) ( )

( ) ( )

⁄ (19.2.4)

Ne discende che la controimmagine dell’isomorfismo di cui all’osservazione c) è un

codice ciclico.

Quanto finora esposto costituisce in pratica la dimostrazione del seguente

teorema:

Codici Ciclici 133

Teorema 19.1

Condizione necessaria e sufficiente affinché un codice sia ciclico è che ( ) sia un

ideale di .

***********

19.3 - Polinomio generatore di un codice ciclico

Ci convinciamo facilmente del fatto che il sottoinsieme di costituito

dall’unione di tutti i laterali di che appartengono ( ) , in virtù della

(19.2.2), è un ideale, ma tutti gli ideali di sono principali (vedi Teorema 18.1),

esiste cioè un polinomio di grado minimo che li genera, tale polinomio apparterrà evi-

dentemente a ( ) ( )

in particolare potremmo scegliere in quest'ultimo

l’unico polinomio monico di grado minimo, sia ( ). Rileviamo che il grado di ( )

dovrà necessariamente essere per un codice .

Abbiamo visto che ( ) , quindi, in virtù del Teorema 18.2, ( )

deve essere un divisore di , ne discende che un codice ciclico esiste se e

solo se , pensato come polinomio a coefficienti nel campo , si può scomporre

nel prodotto tra due polinomi uno dei quali di grado .

19.4 - Polinomio di parità di un codice ciclico

Nel paragrafo precedente abbiamo visto che se ( )( ) genera un codice

ciclico ( ), allora deve esistere

( )( ) ( )( ) ( )( ) (19.4.1)

D’altro canto nel precedente capitolo abbiamo visto che ogni parola di un codice

polinomiale può essere scritta nella forma:

( ) ( ) ( )( ) (19.4.2)

dove a x è un qualsiasi polinomio appartenente a ( )

. Risulta:

( )( ) ( ) ( ) ( )( ) ( )( ) ( )( )

( )( ) ( ) (19.4.3)

Poiché la precedente è vera per tutti e soli i polinomi di codice, ne discende che

( )( ), o un qualunque altro polinomio di che lo contenga come fattore senza

contenere , può essere utilizzato per effettuare il controllo di parità nel caso in

cui si intenda utilizzare il codice esclusivamente per la rivelazione dell’errore.

Il polinomio ( )( ) ( )( ) ( ) ha tutti i coefficienti di grado mag-

giore di e minore di nulli. Questa osservazione ci permette di scrivere le


seguenti equazioni che devono essere soddisfatte dai coefficienti del polinomio

( )( ) ( ):

∑

(19.4.4)

ciascuna delle equazioni appena scritte coinvolge simboli consecutivi della

parola di codice e può quindi essere utilizzata come controllo di parità qualora si

intenda utilizzare il codice per la correzione di errore. Le (19.4.4) potrebbero anche

essere utilizzate per implementare un codificatore sistematico utilizzando un filtro FIR.

Infatti nella prima delle (19.4.4) possiamo scegliere arbitrariamente ,

(in sostanza la parola informativa) e calcolare , quindi utilizzare nella seconda

per calcolare e così via fino ad ottenere una parola di codice. In

sostanza si risolvono ricorsivamente equazioni del tipo

∑

(19.4.5)

Nell’incognita tali equazioni ammettono certamente soluzione dal momento che

deve essere diverso da 0. Se così non fosse, tra le radici di ( ) vi sarebbe lo zero del

campo che non è una radice di , quindi non può esserlo per nessuno dei suoi

fattori.

Esempio 19.1

Vogliamo implementare un codificatore basato sulle (19.4.5) che emetta gli simboli della

parola di codice in sequenza. Osserviamo che il codificatore è sistematico, i simboli informativi

emessi dalla sorgente potranno quindi essere resi disponibili direttamente all’uscita del codificatore.

Nello stesso tempo, al fine di calcolare i simboli di parità essi dovranno essere temporaneamente

memorizzati in uno stack di memoria che nel caso di codici binari si identifica di fatto con uno shift

register. Osserviamo lo schema di Fig.E 19.1, nel quale sono indicati in rosso i simboli presenti nelle

celle di memoria, schematizzate come elementi di ritardo. Ci rendiamo conto che, non appena la

sorgente emette il -esimo simbolo informativo ( ), all’uscita del moltiplicatore posto in serie al

sommatore sarà presente . Il passo successivo consisterà nel chiudere l’anello di reazione,

spostando sulla posizione b il commutatore e mantenerlo in questa posizione per periodi di

clock per calcolare i restanti

simboli di parità.

Osserviamo che ( ) può

essere scelto in modo che

risulti , nel qual caso

sarebbe possibile eliminare il

moltiplicatore in uscita al

sommatore; d’altra parte tale

scelta comporta in genere la

rinuncia ad un polinomio

generatore monico. Nel caso

in cui il codice sia binario, la

sua struttura si semplifica ulteriormente in quanto si potrebbero abolire tutti i moltiplicatori

limitandosi a connettere al sommatore solo le celle di memoria cui corrisponde un coefficiente non

nullo del polinomio di parità. Notiamo anche che in questo caso le celle di memoria si ridurrebbero a

Fig.E 19.1 Codificatore sistematico basato sul polinomio di parità

Codici Ciclici 135

dei Flip Flop. Per concludere osserviamo che il “cuore” di questo codificatore è sostanzialmente un

filtro FIR.

19.5 - Matrice generatrice di un codice ciclico

Consideriamo un codice ciclico sul campo la cui rappresentazione polinomiale

sia l’insieme ( ), abbiamo visto che esso deve ammettere un polinomio generatore

di grado , sia:

( )( ) (19.5.1)

Sappiamo che, in virtù della ciclicità, anche i polinomi ( )( ) ( ) devono

appartenere a ( ). Osserviamo che per i polinomi ottenuti al variare di tra e

risulta

( )( ) ( ) ( )( ) (19.5.2)

Detti polinomi sono linearmente indipendenti, giacché tutti di grado diverso e sono in

numero pari alla dimensione di ( ) pensato come sottospazio di ( )

, ne

costituiscono quindi una base.

Quanto appena detto ci consente di scrivere una matrice generatrice del codice

che avrà evidentemente come righe le parole corrispondenti ai polinomi ap-

pena individuati

[

] (19.5.3)

19.6 - Codici ciclici Sistematici

La matrice generatrice individuata nel paragrafo precedente non è in forma

sistematica, vogliamo mostrare che è possibile individuarne una che lo è.

A tal fine dato un codice ciclico ( ) generato da ( )( ) consideriamo polinomi

del tipo:

(19.6.1)

Essi non sono certamente polinomi di codice in quanto tra le loro radici non compaiono

certamente quelle di ( )( ) , tuttavia sottraendo da ciascuno di essi il resto della

divisione per ( ) otteniamo un polinomio di codice possiamo cioè affermare che:

( ( )) ( ) (19.6.2)

Ci rendiamo conto del fatto che se scriviamo i polinomi ottenuti tramite la

(19.6.2) in corrispondenza a otteniamo polinomi di codice che

hanno il solo coefficiente -esimo pari a uno e tutti i restanti nulli nel range di valori di

in parola, ciò in quanto il resto di una divisione per ( ) è un polinomio che al più


può avere grado . Si costata anche immediatamente che i polinomi appena

ottenuti sono linearmente indipendenti, si possono quindi utilizzare le parole di codice

ad essi associate per costruire una matrice generatrice del codice che sarà del tipo:

(19.6.3)

in grado quindi di generare un codice sistematico con la parte informativa “in coda”

anziché “in testa”.

Da quanto detto discende che il polinomio di codice associato al polinomio

informativo ( ) ( )

è dato da:

( ) ( ) ( ) ( ( )( )) (19.6.4)

Prendiamo adesso in considerazione la matrice

(19.6.5)

che si ottiene effettuando rotazioni cicliche su ciascuna riga della . Essa ha per

righe parole di linearmente indipendenti ed è quindi anch’essa una matrice gene-

ratrice.

Esempio 19.2

Per costruire un codificatore basato sulla (19.6.4) dobbiamo disporre di un sistema in grado di

calcolare il resto della divisione tra due polinomi.

Supponiamo di disporre all’istante - esimo del polinomio ( ), e che tale polinomio all’istante

- esimo venga aggiornato, per effetto dell’emissione da parte di una sorgente di un simbolo

secondo la regola:

( ) ( )

Indichiamo rispettivamente con ( ) e ( ) il resto e il quoto della divisione tra ( )e

( ) che supponiamo monico. Vogliamo calcolare ( ). Risulta:

( ) ( ) ( ( )) ( ) ( ) ( ) ( ( ))

( ) ( ( ))

Ma ( ) ha al più grado possiamo quindi ulteriormente scrivere:

( ) ( ) ( ) ( )

( ) ( ( ) ) (

( ) )

Possiamo quindi facilmente tracciare lo schema di principio mostrato in Fig.E 19.2.

Non appena tutti i

coefficienti del divi-

dendo, a partire da

quello di grado mag-

giore, saranno immessi

nel sistema, sarà

sufficiente aprire l’anel-

lo di reazione tramite il

deviatore in uscita e nei

successivi passi si presenteranno in uscita i coefficienti del resto.

19.7 - Duale di un codice ciclico

Abbiamo mostrato che un codice ciclico ( ), ha come generatore un fattore

( )( ) del polinomio . Esiste quindi un ( )( ) tale che:

Fig.E 19.2 Schema di principio di un sistema che calcola il resto della divisione tra due

polinomi

Codici Ciclici 137

( )( ) ( )( ) (19.7.1)

Abbiamo già visto come ( )( ) possa essere utilizzato come polinomio di parità, ma

esso, in quanto fattore di , è in grado di generare a sua volta un codice ciclico

( ) anch’esso contenuto in ( )

che viene chiamato (seppur

impropriamente) duale di ( ) , in quanto le parole di non sono in genere

ortogonali a quelle di .

Consideriamo due polinomi ( ) ( ) e ( ) ( ). Risulta:

( ) ( ) ( ) ( )( ) ( ) ( )( ) ( ) ( )( ) (19.7.2)

Osserviamo che il polinomio ( ) ( ) ha grado al più ( ) ( )

, ne segue che il coefficiente del termine di grado di ( ) ( ) deve essere

nullo. Possiamo quindi scrivere:

∑

(19.7.3)

la precedente vale per ogni scelta di ( ) ( ) e ( ) ( ) . Essa ci

suggerisce come costruire il codice duale propriamente detto che si ottiene ribaltando le

parole di .

Anche il codice duale propriamente detto è polinomiale il suo polinomio

generatore risulta essere:

( ) (19.7.4)

una sua matrice generatrice potrebbe essere:

[

] (19.7.5)

Capitolo - 20

CAMPI FINITI

20.1 - Polinomi irriducibili e campi a essi associati

Definizione 20.1

Diciamo che un polinomio ( )( ) di grado non inferiore a 1 è irriducibile se:

( )( ) ( )( ) ( )( ) (20.1.1)

Ovviamente tutti i polinomi di primo grado sono irriducibili. In 2 . Anche il

polinomio è irriducibile esso infatti non è divisibile né per né per ,

che sono tutti e soli i polinomi di primo grado appartenenti a 2 . Non sono

necessarie altre verifiche in quanto le eventuali fattorizzazioni devono comunque

contenere un polinomio di primo grado. Il polinomio è irriducibile in ,

ma pensato come elemento di non lo è


Teorema 20.1

Se ( )( ) è un polinomio irriducibile di allora il gruppo quoziente individuato

dall’ideale ( )( ) è un campo.

Dimostrazione:

Sappiamo già che ( )( ) è un anello commutativo con identità, quindi dob-

biamo solo verificare che per ogni suo elemento, fatta eccezione per ( )( ) , esiste

un inverso.

Osserviamo che ( )( ) non coincide con . Infatti, se così non fosse,

esisterebbe ( ) ( )( ) ( ) , ma la precedente può essere soddisfatta

solo se , contro l’ipotesi che ( )( ) è irriducibile, quindi il suo grado non può

essere inferiore ad . Possiamo pertanto affermare che ( )( ) contiene almeno

un polinomio ( ) ( )( ) .

Consideriamo adesso l’insieme

{ ( ) ( )( ) ( ) ( ) | ( ) ( ) (20.1.2)

si constata facilmente che è un ideale di , ma (vedi Teorema 18.1) tutti gli ideali

di sono principali, deve pertanto esistere in un polinomio ( )( ) tale che

risulti ( )( ) .


Dalla (20.1.2) deduciamo che ( )( ) , quindi deve esistere un polinomio per

il quale risulti ( )( ) ( )( ) ( )( ), ma ( )( ) è irriducibile, quindi, necessa-

riamente, o , o . Nel primo caso ( )( ) , ma ciò è assurdo perché

contiene anche ( )( ) ( )( ) , deve quindi essere . Ciò implica

da cui discende che esistono ( ) ( ) che soddisfano l’uguaglianza

( ) ( )( ) ( ) ( )( ) (20.1.3)

La precedente implica:

( )( ) ( ( )( ) ( )( ) ( )( ) ( )( )) ( )( ) ( )( ) ( )( ) ( )( ) ( )( ) ( )( ) ⊗ ( )( ) ( )( )

(20.1.4)

Osservando primo e ultimo membro della precedente si deduce che il laterale

( )( ) ( )( ) è l’inverso di ( )( ) ( )( ) .

***********

20.2 - Ordine degli elementi di un gruppo

Consideriamo un gruppo finito , abbiamo già visto che ogni suo sottogruppo

individua una partizione del gruppo in laterali, che hanno tutti la stessa cardinalità del

sottogruppo. Ciò comporta il fatto che il numero di elementi di un sottogruppo, il suo

ordine ( ), è un sottomultiplo dell’ordine del gruppo in cui esso è contenuto.

Sia un elemento di un gruppo finito . Consideriamo l’insieme:

(20.2.1)

è un sottoinsieme di , in quanto è chiuso rispetto alla legge , quindi deve

avere un numero finito di elementi, da cui facilmente discende che deve esistere un

intero ( ), tale che risulti , o, che è lo stesso, tale che

(20.2.2)

Abbiamo appena mostrato che contiene . Considerando adesso il più piccolo

valore di che soddisfa la (20.2.2), risulta:

(20.2.3)

è quindi un sottogruppo di . L’ordine del sottogruppo generato da un elemento

di un gruppo è detto ordine di , ( ).

20.3 - Ordine degli elementi di un campo finito

Consideriamo un campo finito . Sia l’ordine di rispetto alla legge , possia-

mo affermare che è un numero primo. Infatti, se così non fosse, esisterebbero due

interi, ed , entrambi per i quali varrebbe l’uguaglianza:

( ) ⊗ (20.3.1)

Campi Finiti 141

ma è un campo vale quindi la legge di annullamento del prodotto, quindi o o

. ( ) sarebbe quindi il minimo tra ed e non . Ne segue che ( ) deve

essere un primo.

Osserviamo che per ogni elemento di si può scrivere ⊗ , da cui:

2 ( ⊗ ) ( ⊗ ) ⊗( ) ⊗ 2 (20.3.2)

più in generale ⊗ , ma ⊗ solo se , ovvero se ,

possiamo quindi concludere che tutti gli elementi diversi da di un campo finito hanno

lo stesso ordine rispetto alla somma, e che tale ordine è un primo risulta cioè:

(20.3.3)

20.4 - Ordine di un campo finito

Consideriamo un campo , ed un suo sottocampo , in questo caso diremo che

è un’estensione di . Si constata che ha la struttura di spazio vettoriale sul campo ,

se la dimensione di questo spazio è finita è detta grado di su .


Teorema 20.2 - Ordine di un campo finito

L’ordine di un campo finito o è un primo, o è una potenza (intera) di un primo.

Dimostrazione:

Abbiamo visto che l’ordine dell’elemento e di un qualsiasi campo è un primo p , si

verifica facilmente che l’insieme

2 3 (20.4.1)

é un campo (isomorfo a ) quindi è un sottocampo non necessariamente proprio (in

quanto potrebbe coincidere con ) di .

D’altro canto, ha la struttura di spazio vettoriale sul campo e la sua dimen-

sione deve necessariamente essere finita, essendo finito per ipotesi.

Un qualsiasi elemento di potrà essere quindi espresso in modo univoco come

combinazione lineare, con coefficienti appartenenti a , di elementi che costituiscano

una base per , cioè che siano linearmente indipendenti su . Osservando che esistono

esattamente combinazioni lineari distinte si conclude che l’ordine di se non è

primo è una potenza di un primo.

***********

Quale che sia il campo finito , il campo generato dalla sua unità

moltiplicativa è detto sottocampo primo o fondamentale. Esso è contenuto in tutti i


sottocampi di , o, che è lo stesso, è l’intersezione di tutti i sottocampi di

quindi è anche il più piccolo sottocampo di che contiene (si dice che è la

caratteristica del campo).

Osserviamo che se un Campo non è finito, allora anche l’insieme definito nella

(20.4.1) non lo è, e non è neppure un sottocampo di (non è nemmeno un gruppo) in

questo caso si può dimostrare che il sottocampo minimo contenuto in è isomorfo al

campo dei razionali e che l’insieme definito nella (20.4.1) è isomorfo all’insieme

dei naturali. In questo caso diremo che il campo ha caratteristica

20.5 - Elementi primitivi di un campo

Sappiamo che un campo privato dell’elemento neutro rispetto alla somma è

un gruppo rispetto alla moltiplicazione, indichiamolo con ⊗ . L’ordine di

⊗ è

.

Sia l’ordine di un generico elemento di ⊗ , risulta

⊗ ⊗ ⊗ ⊗ ⏟ fattori

(20.5.1)

deve necessariamente essere un divisore di esiste cioè un naturale tale che

. Ne segue:

( ) (20.5.2)

Dalla precedente discende che per ogni elemento di ⊗ potremo scrivere:

⊗ (20.5.3)

Constatiamo immediatamente che la precedente vale anche per , possiamo quindi

anche scrivere:

(20.5.4)

Si può dimostrare che il gruppo ⊗ è un gruppo ciclico, cioè che in

⊗ vi

sono elementi il cui ordine è uguale all’ordine del gruppo. Un tale elemento si chiama

generatore del gruppo.

Un generatore di ⊗ si dice elemento primitivo del campo, in particolare si

può dimostrare che vi sono elementi primitivi in numero uguale a quello dei naturali

e con esso relativamente primi, ad esempio in ve ne saranno , in

. Inoltre in ogni campo per cui è un primo, quale ad esempio tutti gli

elementi diversi da sono primitivi.

20.6 - Campi di polinomi

Cerchiamo adesso di mettere un po’ d’ordine, sappiamo che:

Campi Finiti 143

- se ( )( ) è un polinomio irriducibile appartenente a , allora ( )( ) è

un campo.

- ogni campo finito ha un numero di elementi che se non è un numero primo è

una potenza di un primo;

-

( ) , è isomorfo ad uno spazio vettoriale di dimensione , costi-

tuito esattamente da ( ) elementi (una potenza di un primo).

Fissato un polinomio irriducibile ( )( ), a coefficienti in e comunque

scelto un polinomio ( )( ) di possiamo scrivere:

( )( ) ( )( ) ( )( ) ( )( ) (20.6.1)

La precedente ci mostra che ( )( ) ed ( )( ) , appartengono allo stesso laterale

dell’ideale generato da ( )( ). Notiamo anche che il grado di ( )( ) è, inferiore al

grado di ( )( ).

Osserviamo che ( )( ) può essere un qualunque polinomio appartenente a

( )

in definitiva quindi, individuato un polinomio irriducibile ( )( ), possiamo

affermare che ( )

, con l’usuale somma tra polinomi in e definendo come

prodotto tra due suoi elementi il resto della divisione tra il loro prodotto in e

( )( ), è un campo isomorfo a ( )( ) , in quanto ogni elemento di ( )

individua uno e un solo laterale di ( )( ) , e viceversa.

Esempio 20.1

Consideriamo l’anello dei

polinomi sul Campo .

Il polinomio è irridu-

cibile. Pertanto è un campo, di ordine , in quanto

sono i polinomi di grado minore di a

coefficienti in . Osserviamo che tutti

i suoi elementi non nulli sono primiti-

vi in quanto il gruppo ⊗ ha ele-

menti, e sette è un primo. In particola-

re anche l’elemento sarà primitivo. Assumendo

come rappresentanti di laterale i polinomi di grado inferiore a otterremo la Tabella 20.1, nella

quale abbiamo convenzionalmente indicato l’elemento neutro rispetto alla somma con e, nella

quarta colonna, abbiamo associato ai rappresentanti di laterale le corrispondenti parole binarie di

bit.

20.7 - Polinomi irriducibili primitivi

Consideriamo adesso un campo e una sua estensione .

𝛼 𝑥 𝑥 𝑥 010

𝛼 𝑥 𝑥 𝑥 100

𝛼 𝑥 𝑥 𝑥 011

𝛼 𝑥 𝑥 𝑥 𝑥 𝛼 𝛼 110

𝛼 𝑥 𝑥 𝑥 𝑥 𝛼 𝛼 111

𝛼 𝑥 𝑥 𝑥 𝛼 𝛼 101

𝛼 𝑥 𝑥 001

𝛼 000

Tabella 20.1


Definizione 20.2

Diciamo che un elemento è algebrico su se esiste un polinomio ( )( ) di

che ha come radice, cioè tale che effettuando le operazioni in risulti

( )( ) .

Consideriamo ad esempio il campo dei razionali e la sua estensione (il

campo Reale) l’elemento √ è algebrico su in quanto il polinomio ha

√ tra le sue radici se lo si pensa come un polinomio appartenente a .

Osserviamo che l’insieme contenente i polinomi che hanno tra

le radici è un ideale di . Infatti, comunque scelto un polinomio in moltiplican-

dolo per un qualunque polinomio di si ottiene ancora un polinomio che ha tra le

sue radici.

L’ideale deve ammettere quindi un polinomio generatore sia ( )( ) ,

osserviamo che esiste sempre un polinomio generatore che ha come coefficiente del

termine di grado massimo. Un tale polinomio sarà detto monico, da ora in poi quando

parleremo di polinomio generatore sottintenderemo che sia quello monico.

Il polinomio ( )( ) è irriducibile in , (non è detto che lo sia in ) in

quanto se così non fosse almeno uno dei fattori in cui potrebbe essere scomposto am-

metterebbe come radice. Tale fattore apparterrebbe quindi ad , ed avrebbe grado

inferiore a ( )( ), ( )( ) non sarebbe quindi in grado di generarlo e perverremmo ad

un assurdo.

Da quanto sopra segue che esiste un unico polinomio generatore monico di che

è chiamato polinomio minimale di su .

Osserviamo che ogni elemento di è algebrico su . Inoltre è facile constatare

che se è finito ogni elemento di è algebrico sul suo sottocampo primo, in quanto

si annulla in virtù della (20.5.2) ⊗.

Definizione 20.3

Diciamo che un polinomio irriducibile ( )( ) è primitivo se esso è fattore

di e non di con .


Teorema 20.3

Se ( )( ) è un polinomio irriducibile di l’elemento ( )( )

( )( ) è primitivo per ( )( ) se e solo se ( )( ) è un

polinomio primitivo.

Campi Finiti 145

20.8 - Alcune proprietà dei campi finiti

Consideriamo due elementi e di ci convinciamo facilmente che vale

l’uguaglianza:

( ) ∑( )[(

)]

∑( )[(

)]

(20.8.1)

Osserviamo adesso che i coefficienti binomiali nella sommatoria a ultimo membro sono

multipli di , essendo primo, ciò premesso ci basta ricordare la (20.3.3) per

concludere che tutti gli addendi della sommatoria all’ultimo membro della precedente

sono uguali ad ne discende che

( ) (20.8.2)

Risulta anche:

( ) ( ) ( )

(20.8.3)

Dalle precedenti sfruttando la proprietà associativa della somma e tenuto conto

che la precedente può essere applicata iterativamente otteniamo l’equazione:

( )

(20.8.4)

Un interessante caso particolare si ha quando si eleva a una combinazione

lineare di elementi di pensato come spazio vettoriale sul suo sottocampo primo:

(∑

)

∑

(20.8.5)

La precedente consente di affermare che per un qualsiasi polinomio ( )( )

risulta:

( ( )( )) (∑

)

∑ ( )

( ) ( ) (20.8.6)

dalla quale discende immediatamente che, se il polinomio ammette come ra-

dice, ammette anche con . Tali radici non saranno ovviamente tutte distinte.

Esempio 20.2


Vogliamo costruire un campo con elementi . Per farlo abbiamo bisogno di individuare

un polinomio irriducibile a coefficienti in di quarto grado.

Prendiamo quindi in considerazione il polino-

mio . Detto polinomio non è divisibile

per poiché non è omogeneo né per poiché

ha un numero dispari di coefficienti non nulli.

quindi non è divisibile neppure per polinomi di

terzo grado. Esso non è divisibile neppure per i

polinomi di secondo grado , , , pertanto è irriducibile.

Dovremmo a questo punto verificare che si

tratta di un polinomio primitivo, accertandoci che

non è un fattore di con . Tale

verifica è piuttosto noiosa, d’altro canto, qualora il

polinomio in parola non fosse primitivo lo scopri-

remmo facilmente in quanto il polinomio non sa-

rebbe un elemento primitivo per il campo, esso a-

vrebbe cioè un ordine inferiore a .

A partire dal polinomio che associamo al-

l’elemento del campo cominciamo a riempire la

Tabella 20.2 con il resto della divisione tra le

successive potenze di e il polinomio . Come si può notare dalla Tabella 20.2 il

polinomio è primitivo in quanto l’ordine di .

Nella terza colonna della Tabella abbiamo indicato

la rappresentazione binaria dei polinomi.

Abbiamo a questo punto generato gli elementi

del campo.

Per operare più rapidamente su di esso possiamo costruire la Tabella 20.3 che riassume tutti i

possibili risultati di somme e prodotti tra gli elementi del campo. È opportuno sottolineare che tale

tabella dipende dal polinomio irriducibile scelto nel senso che se avessimo utilizzato un polinomio

diverso avremmo ottenuto una diversa rappresentazione di e conseguentemente una Tabella

20.3 diversa. Un modo alternativo per fare le somme in un campo finito è quello di fare riferimento

ai logaritmi di Zech. Supponiamo di voler calcolare la somma di due elementi siano ed

entrambi diversi da possiamo scrivere:

𝔾𝔽

𝑥 𝑥 𝑥 𝑥 𝛼 0010

𝑥 𝑥 𝑥 𝑥 𝛼 0100

𝑥 𝑥 𝑥 𝑥 𝛼 1000

𝑥 𝑥 𝑥 𝑥 𝛼 1001

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1011

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1111

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 0111

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1110

𝑥 𝑥 𝑥 𝑥 𝛼 0101

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1010

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1101

𝑥 𝑥 𝑥 𝑥 𝛼 0011

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 0110

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1100

𝑥 𝑥 𝑥 𝛼 0001

𝑥 𝑥 𝛼 0000

Tabella 20.2 - possibile rappresentazione di

𝔾𝔽

𝑜 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑒

𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜 𝑜

𝛼 𝛼 𝑜 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑒 𝛼 𝛼

𝛼 𝛼 𝛼 𝑜 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑒 𝛼 𝛼 𝛼

𝛼 𝛼 𝛼 𝛼 𝑜 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑒 𝛼 𝛼 𝛼 𝛼

𝛼 𝛼 𝛼 𝛼 𝑒 𝑜 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑒 𝛼 𝛼 𝛼 𝛼 𝛼

𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑜 𝛼 𝛼 𝛼 𝛼 𝛼 𝑒 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼

𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑜 𝛼 𝛼 𝛼 𝑒 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼

𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑜 𝛼 𝑒 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼

𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑒 𝛼 𝑜 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼

𝛼 𝛼 𝛼 𝑒 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑜 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼

𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑒 𝛼 𝛼 𝛼 𝛼 𝑜 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼

𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑜 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼

𝛼 𝛼 𝑒 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑜 𝛼 𝛼 𝛼 𝛼 𝛼

𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑒 𝛼 𝛼 𝛼 𝛼 𝛼 𝑜 𝛼 𝛼 𝛼 𝛼

𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑒 𝛼 𝛼 𝑜 𝛼 𝛼 𝛼

𝑒 𝑒 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑜 𝑒 𝑒

𝑜 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝛼 𝑒

Tabella 20.3 Addizioni e moltiplicazioni in 𝔾𝔽

Campi Finiti 147

( ) (20.8.7) Osserviamo che il termine in parentesi appartiene ovviamente al campo e si può quindi esprimere

sotto forma esponenziale e notiamo

inoltre che dipende esclusivamente dalla

differenza tra gli esponenti , che va

valutata modulo la cardinalità di

,

ovvero .

Possiamo quindi scrivere

( ) , convenendo che ( )

qualora dovesse risultare ,

(in tutte le estensioni di ogni ele-

mento ha se stesso come opposto, ma

non è vero in generale!).

I possibili valori assunti dalla quantità

in parentesi si possono leggere nella

Tabella 20.3. e possiamo scrivere

( )

( ) (20.8.8)

La funzione ( ) è detta

logaritmo di Zech. Essa, ovviamente,

dipende sia dalla scelta del polinomio

irriducibile, sia da quella dell’elemento

primitivo. Il vantaggio nell’utilizzazione

del logaritmo di Zech, anziché della

Tabella 20.3, consiste nel fatto che la

tabella che si ottiene è più compatta

essendo costituita solo da valori

contro i ( ) della parte

additiva della Tabella 20.3 che diventa

ben presto ingestibile al crescere della

cardinalità del campo.

Si osservi che qualora avessimo

utilizzato il polinomio , an-

ch’esso irriducibile e primitivo, per gene-

rare avremmo ottenuto la rappre-

sentazione di Tabella 20.5 per la quale la

Tabella 20.3 e la Tabella 20.4 do-

vrebbero essere riscritte. Il logaritmo di

Zech si presta inoltre meglio ad essere

implementato in un programma di

calcolo.

𝑘 𝑚𝑜𝑑 𝑧(𝑘)

Tabella 20.4 logaritmo di Zech per la rappresentazione di

𝔾𝔽 dell’Esempio 20.2

𝔾𝔽

𝑥 𝑥 𝑥 𝑥 𝛼 0010

𝑥 𝑥 𝑥 𝑥 𝛼 0100

𝑥 𝑥 𝑥 𝑥 𝛼 1000

𝑥 𝑥 𝑥 𝑥 𝛼 0011

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 0110

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1100

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1011

𝑥 𝑥 𝑥 𝑥 𝛼 0101

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1010

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 0111

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1110

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1111

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 1101

𝑥 𝑥 𝑥 𝑥 𝛼 1001

𝑥 𝑥 𝑥 𝛼 0001

𝑥 𝑥 𝛼 0000

Tabella 20.5 – altra possibile rappresentazione di 𝔾𝔽

Capitolo - 21

CODICI BCH

21.1 - Codici BCH

Supponiamo di voler generare un codice polinomiale con parole di lunghezza i

cui simboli appartengano a un campo che abbia una distanza minima non inferiore

a .

Un modo per farlo è quello di scegliere un’estensione di di grado con un

numero di elementi pari a , sia . In detto campo sceglieremo un elemento

primitivo e costruiremo il polinomio ( ) di grado minimo che ha come

radici gli elementi dell’insieme con . Detto

polinomio sarà evidentemente il minimo comune multiplo tra i polinomi minimali

associati agli .

Affermiamo che un polinomio ( ) così costruito è in grado di generare un codi-

ce con distanza minima non inferiore a . Per provarlo osserviamo che l’insieme delle

radici di ogni polinomio associato a una parola di codice conterrà l’insieme

. Affinché un codice abbia distanza minima pari almeno a non

devono esistere parole di codice, ad eccezione di quella nulla, che abbiano meno di

simboli diversi da .

Supponiamo per assurdo che un codice generato nel modo anzidetto non rispetti

questa condizione, in questo caso esisterà almeno una parola di codice individuata da

un polinomio del tipo:

( )

(21.1.1)

Essendo ( ) un polinomio di codice l’insieme delle sue radici conterrà l’insieme

devono quindi essere contemporaneamente soddisfatte le equazioni:

{

( )

( ) ( )

( ) ( )

( )

(21.1.2)

Abbiamo così ottenuto un sistema lineare e omogeneo di equazioni in

incognite.

La matrice dei coefficienti del sistema di cui sopra è:


[

( ) ( ) ( )

( ) ( ) ( )

] (21.1.3)

che si può scrivere come segue:

[

( ) ( ) ( )

] [

] (21.1.4)

osserviamo che la prima matrice a secondo membro è una matrice di Vandermonde il

suo determinante vale pertanto:

∏( )

(21.1.5)

è quindi non singolare, poiché, per ipotesi, è un elemento primitivo di quindi

il suo ordine è maggiore di , ne discende che tutti i binomi della produttoria

(21.1.5) sono diversi da , inoltre il determinante della seconda matrice è certamente

diverso da in quanto essa è diagonale e gli elementi della diagonale sono tutti diversi

da .

Possiamo quindi concludere che il sistema (21.1.2) è di Cramer ed essendo anche

omogeneo esso ammette solo la soluzione banale. Non esistono pertanto parole di

codice, ad eccezione di quella con simboli tutti nulli, che abbiano meno di simboli

diversi da .

Quanto appena mostrato permette di costruire un’importante classe di codici detti

BCH, dalle iniziali dei loro scopritori: Bose (1959), Chaundhuri e Hocquenghem

(1960). Alla classe dei codici BCH appartengono anche i codici di Hamming che

abbiamo già visto, nonché i codici di Reed Solomon (RS).

Osserviamo che i codici BCH sono ciclici in quanto il loro polinomio generatore

ha tra le sue radici un sottoinsieme di quelle di pensato come polinomio a

coefficienti in , esso ne è pertanto un fattore.

Osserviamo anche che il grado del polinomio generatore non è assegnato a priori,

ma dipende dalla scelta dell’elemento primitivo di . ne segue che anche il numero

di simboli che costituiscono la parola informativa non può essere prefissato. Inoltre la

distanza minima del codice potrebbe anche risultare maggiore di quella di progetto.

Tipicamente i simboli che costituiscono la parola di codice appartengono a un campo

, cioè ad un campo con un numero di elementi che sia una potenza di .

Esempio 21.1

Codici BCH 151

Vogliamo realizzare un codice BCH con una parola di codice di bit in grado di correggere

almeno errori quindi con una distanza minima pari almeno a . Per farlo abbiamo bisogno di di

generare .

Possiamo verificare che é un polinomio irriducibile primitivo. A partire da

quest’ultimo ricaviamo la Tabella 21.1, da essa possiamo facilmente calcolare i logaritmi di Zech

riportati in Tabella 21.2.

Possiamo quindi procedere alla costruzione del polinomio generatore a coefficienti in , che

deve avere come radici 6 potenze consecutive di un elemento primitivo . Possiamo scegliere:

Tale scelta ha il vantaggio di semplificare la ricerca del polinomio generatore, in quanto il

polinomio minimale associato ad tenendo conto della (20.8.6) è anche minimale per ed

quello di lo è anche per . Il polimomio generatore cercato sarà quindi il prodotto di tre

polinomi minimali, quello associato ad , quello associato ad e quello associato ad .

Osserviamo che se avessimo scelto il polinomio generatore avente come radici:

Esso avrebbe avuto certamente un grado non minore di quello associato alla scelta precedente in

𝑘 𝑚𝑜𝑑 𝑧(𝑘)

Tabella 21.2

𝔾𝔽

𝑜 𝑥 𝑥 𝑜 00000

𝑥 𝑥 𝑥 𝑥 𝛼 00010

𝑥 𝑥 𝑥 𝑥 𝛼 00100

𝑥 𝑥 𝑥 𝑥 𝛼 01000

𝑥 𝑥 𝑥 𝑥 𝛼 10000

𝑥 𝑥 𝑥 𝑥 𝛼 00101

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 01010

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 10100

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 01101

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 11010

𝑥 𝑥 𝑥 𝑥 𝛼 10001

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 00111

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 01110

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 11100

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 11101

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 11111

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 11011

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 10011

𝑥 𝑥 𝑥 𝑥 𝛼 00011

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 00110

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 01100

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 11000

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 10101

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 01111

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 11110

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 11001

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 10111

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 01011

𝑥 𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 10110

𝑥 𝑥 𝑥 𝑥 𝛼 01010

𝑥 𝑥 𝑥 𝑥 𝑥 𝛼 10010

𝑥 𝑥 𝑥 𝑒 00001

Tabella 21.1 - Possibile rappresentazione di 𝔾𝔽


quanto oltre ai tre fattori citati avrebbe dovuto avere tra i suoi fattori il polinomio minimale associato

ad . L’aumento del grado del polinomio generatore comporta inevitabilmente una riduzione del

grado del polinomio informativo, in questo caso specifico poi la distanza minima di progetto sarebbe

anche aumentata perché il polinomio generatore avrebbe avuto almeno 7 potenze consecutive di

tra le sue radici.

La ricerca dei polinomi minimali può essere fatta per tentativi possiamo solo ridurne il numero.

Nel caso ad esempio del polinomio minimale associato ad sappiamo che esso avrà anche le radici

quindi dovrà essere almeno di quinto grado, possiamo quindi cominciare a prendere

in considerazione i polinomi non omogenei di 5 grado con un numero dispari di coefficienti, in

quanto quelli con un numero pari di coefficienti, essendo divisibili per , non sarebbero

irriducibili. Restano quindi 8 possibili polinomi di quinto grado da prendere in considerazione.

Il polinomio minimale associato ad è che sia una sua radice si constata

immediatamente osservando che e , appartengono allo stesso laterale (vedi Tabella 21.1),

esso è anche irriducibile in quanto è proprio il polinomio che abbiamo utilizzato per generare il

campo.

Il polinomio irriducibile associato ad deve avere tra le sue radici anche ,

anch’esso avrà quindi un grado non inferiore al quinto il polinomio che cerchiamo è . Proviamo a verificare che è una sua radice. Utilizzando i logaritmi di Zech (vedi Tabella

21.2) otteniamo:

=

Dobbiamo anche verificare che è irriducibile non avendo tra i suoi fattori nessun polinomio di

primo grado, verifichiamo che non ne abbia di secondo grado. Ovviamente esso non è divisibile per

, non lo è neppure per ne per , quindi è irriducibile in quanto non possono

esistere fattori di terzo grado, se non ve ne sono di secondo, in un polinomio di quinto grado.

Il polinomio minimale associato ad è , come si può analogamente

verificare.

Possiamo a questo punto calcolare il polinomio generatore del codice che sarà il prodotto dei tre

polinomi minimali sopra indicati che sarà di quindicesimo grado:

( ) ( )( )( ) ( )( )

=

Poiché il polinomio di codice è di trentesimo grado e il polinomio generatore di quindicesimo il

polinomio informativo sarà anch’esso di 15 grado la parola informativa sarà quindi costituita da 16

bit, avremo quindi 65536 parole di codice immerse in uno spazio di parole (tutte le

possibili parole costituite da 31 bit.

Le parole di codice si possono a questo punto generare moltiplicando il polinomio associato alla

parola informativa per il polinomio generatore, ma in questo caso il codice non sarebbe sistematico,

ovvero possiamo ricordare che i codici BCH sono ciclici e basandoci sul § 19.6 - possiamo generare

le parole di codice a partire da un polinomio informativo ( ) effettuando rotazioni cicliche sulla

parola di codice

( ) ( ) ( ) ( ( ))

In particolare i codici di Reed Solomon, che sono certamente i più importanti tra

i codici BCH, hanno simboli appartenenti a , lunghezza della parola di codice

, lunghezza della parola informativa qualsiasi, purché (ovviamente)

minore di , e distanza minima .

Un codice di RS che ha trovato diverse applicazioni pratiche è il (255,239, 17)

che presenta una distanza minima di 17 con simboli appartenenti a , cioè costituite

da un byte, il che significa che pensato come codice binario la parola di codice è di

bit e la corrispondente parola informativa di bit. Questo codice è

in grado di correggere fino ad byte errati indipendentemente dal numero di bit errati

nel byte.

Codici BCH 153

Capitolo - 22

LA TRASFORMATA DI FOURIER DISCRETA

22.1 - La Trasformata di Fourier Discreta

Ricordiamo che la trasformata (DFT) e l’antitrasformata (IDFT) di Fourier

discreta di una sequenza a valori nel campo complesso di durata , o periodica

di periodo è data da:

∑

∑

∑

∑

(22.1.1)

dove rappresenta una radice -esima dell’unità, in altri termini nelle (22.1.1)

compaiono le radici appartenenti al campo complesso del polinomio, a coefficienti in

, . Si noti che il campo complesso è un’estensione del campo reale.

Volendo generalizzare le (22.1.1) ai campi finiti, occorre innanzitutto soffermarsi

sull’esistenza della radice -esima dell’unità del campo. Ricordando la (20.5.1) e la

(20.5.3) concludiamo che se operiamo in la lunghezza della sequenza deve

essere un divisore di .

Ciò premesso consideriamo una sequenza ed una radice -esima

dell’unità in , cioè un elemento di ordine per il gruppo , sia .

Prendendo spunto dalle (22.1.1) possiamo scrivere la coppia di trasformate

∑

∑

(22.1.2)

Vogliamo verificare se esiste un elemento in corrispondenza al quale risulti

. A tal fine sostituiamo la prima delle (22.1.2) nella seconda:


∑ ∑

∑ ∑ ( )

(

∑

∑ ∑ ( )

)

(

∑

∑ ∑ ( )

)

{

∑{ ( )

( ) ( )

( ) }

}

(22.1.3)

Affinché le (22.1.1) siano una coppia di trasformate è quindi sufficiente che sia

l’inverso di in , in realtà è anche l’inverso di in .

Possiamo quindi scrivere la coppia di trasformate:

∑

( ) ∑

(22.1.4)

Per la DFT su un campo finito valgono quasi tutte le proprietà già note per quella

nel campo complesso, ad esempio la linearità, la cui verifica è banale, o quella di

traslazione ciclica.

Sia data una sequenza , la cui DFT sia

, fissato un intero

consideriamo la sequenza il cui generico elemento , dove sta ad

indicare che la differenza va effettuata modulo . Vogliamo calcolare la DFT di

otteniamo:

∑

∑

∑

( )

∑

(22.1.5)

Dualmente fissato un intero j consideriamo la sequenza 1

0

NijN i ic la sua

DFT vale:

∑

∑

( )

(22.1.6)

La Trasformata di Fourier Discreta 157

Alla sequenza possiamo associare il polinomio:

( ) (22.1.7)

lo stesso possiamo fare per la sua DFT , ammesso che esista, definendo in

modo analogo un polinomio ( ) di grado al più . Osservando le (22.1.4) ci

rendiamo conto che risulta:

(

)

( ) ( )

(22.1.8)

Dalle precedenti discende che se allora ( ) ha

come radice, o, che è lo

stesso, ha il polinomio

tra i suoi fattori. Analoghe considerazioni possono farsi

su ( ) se qualche .

Consideriamo una sequenza non banale cui corrisponda un ( )di grado

non maggiore di . Detto polinomio può avere al più radici che

qualora coincidessero tutte con le , comporterebbero l’annullamento di non più di

elementi della che conseguentemente avrebbe almeno elementi

non nulli. Applicando la (22.1.5) possiamo facilmente concludere che è in realtà

sufficiente che in una sequenza non banale siano nulli elementi consecutivi

(modulo ), affinché la sequenza trasformata, o antitrasformata abbia almeno

elementi non nulli.

22.2 - DFT e codici ciclici

Le considerazioni fatte dopo la (22.1.8) ci permettono di introdurre una

definizione alternativa per i codici ciclici. Possiamo infatti affermare che

Definizione 22.1

Un codice ciclico ( ) è costituito dal sottoinsieme di la cui DFT si annulla in

posizioni prefissate.

La definizione appena data comporta ovviamente l’esistenza della DFT, deve

esistere cioè un elemento di ordine per ⊗

, che consenta di calcolarla, ne discende

che deve essere un sottomultiplo di , cioè una radice -esima dell’unità di

. Se vogliamo che le parole di codice abbiano la massima lunghezza l’elemento

scelto per il calcolo della DFT dovrà essere primitivo. In questo caso avremmo

. Il fatto che la Definizione 22.1 sia equivalente alla Definizione 19.1

risulta evidente tenendo conto della (22.1.8) che ci permette di affermare che ogni

polinomio di un codice costruito sulla base della Definizione 22.1 è multiplo di uno


stesso polinomio che è a sua volta un fattore di inteso come polinomio a

coefficienti in .

Documents

Appunti di Teoria dell'Informazione e Codici - tti.unipa.itgarbo/Teoria InfeCodici_2012_01_12.pdf · Capitolo - 1 - Appunti di Teoria dell’Informazione e Codici ∑ ( ) A (1.1.1)