Teoria dell’informazione

• Codifica di canale e di sorgente: la prima aggiunge codice ridondante, la seconda comprime.

• Sorgente: ho un alfabeto di simboli s1, s2, sq questi simboli escono con una probabilità pi.
Le pi sono tali che 0<=pi<=1 e sommatoria di pi=1. L’obiettivo è quello di minimizzare la
lunghezza media calcolata come L= sommatoria pi*li
• Codice di Van Duren: è un codice 3 su 7. significa che 3 bit su 7 valgono 1. Ho 35
combinazioni
• Codice 01247: assegno dei pesi ai bit. 0 al primo, 1 al secondo, 2 al terzo, 4 al quarto, 7 al
quinto. È un codice 2 su 5.
• Controllo di parità: pari: aggiungo un bit di controllo dopo il messaggio. Vale zero se il
numero di 1 nel messaggio è pari, 1 se è dispari.
Dispari: aggiungo un bit di controllo dopo il messaggio. Vale uno se il
numero di 1 nel messaggio è dispari, zero se è dispari. Si usa più spesso nella
pratica, nel caso in cui il messaggio è composto da molti zeri.
• Probabilità di errore: suppongo che ci sia un rumore sempre costante chiamato
rumore bianco. Suppongo che ogni posizione abbia la stessa p di avere un errore e le posizioni
siano indipendenti tra di loro. Se p=0 sarebbe una condizione ideale mai verificata; se p=1
significa che è sempre sbagliato, basta negare tutto; se p=1/2 è un generatore di numeri casuali.
-> non esistono. Per calcolare la probabilità di avere k errori uso la binomiale: p(k)= n su k *
p^k* q^n-k, posso approssimare con p(k)= n su k* p^k dato che gli altri termini sono
trascurabili
• Ridondanza: è il rapporto tra il numero totale di cifre spedite e il numero di cifre
del messaggio. Lo scopo è quello di minimizzarla. Si calcola come R= 1+ cifre di controllo/
cifre totali. Devo quindi minimizzare il numero di bit di controllo. Nel controllo di parità la
ridondanza è: 1+ 1/n-1 e la probabilità di non accorgersi di un errore è data da 1+(1-2p)^n/2 –
(1-p)^n-> è la probabilità di commettere un numero di pari di errore.
• Burst di errori: è un insieme di errore ravvicinati, per gestirlo faccio una parità
per colonna e spedisco un intero byte di controllo. Per risolvere un errore posso anche usare 3
linee di trasmissione e prendere il simbolo con frequenza massima.
• Codici pesati: suppongo di avere un alfabeto di 36 caratteri (10 cifre+ 1 spazio+
25 lettere). Per ogni messaggio viene inviata una cifra di controllo. Questa cifra di controllo ha
peso 1. Con questa codifica se avviene uno scambio fra simboli adiacenti, l’unico modo per non
accorgersi è che i simboli siano uguali. La cifra di controllo è data da (22+26)mod37=11. c= 37-
11=26=Q. Viene spedito il simbolo Q come cifra di controllo. Il ricevente ricalcola la stessa
tabella e deve controllare solo che la somma modulo 37 sia 0.
• Codici rettangolari: i messaggi sono strutturati a rettangolo, con le cifre di
controllo sull’ultima colonna e sull’ultima riga. Se avviene un solo errore, il codice rettangolare
sa identificare la posizione e quindi può correggerlo. La ridondanza vale R=m*n/(n-1)*(m-1).
L’algoritmo è più efficiente se il rettangolo tende ad essere un quadrato. Si possono aggiungere
bit fittizi di messaggio per creare un quadrato. Il numero di cifre di controllo (parità) è dato da
n+m-1.
• Codici triangolari: i messaggi sono strutturati a triangolo, le cifre di controllo
sono meno rispetto ai codici rettangolari. Ho n cifre di controllo e sommatoria i cifre di
messaggi. Il numero di bit totali inviati è di (n+1)n/2. la ridondanza è data da R=n+1/n-1.
l’eccesso di ridondanza è dato da 2/n-1. I codici triangolari sono più efficienti di quelli
rettangolari.
• Codici cubico: ha 3(n-1)+1 cifre di parità, (n-1)^3 cifre di messaggio e 3/n^3 è
l’eccesso di ridondanza.
• Codice di hamming: suppongo che ci sia rumore bianco, il codice di hamming è
un codice capace di correggere un errore. Suppongo di avere un messaggio composto da n bit, k
cifre di messaggio e m cifre di controllo. Ho bisogno di n combinazioni per specificare la
posizione in cui è avvenuto l’errore. Deve essere 2^m>=n+1. questo codice mi permette di
correggere errori anche tra le cifre di controllo. Il mittente calcola le cifre di controllo facendo la
XOR nel seguente modo: prima cifra di controllo = un bit si un bit no; seconda cifra di
controllo: due bit si, due bit no; terza cifrea di controllo= 4 bit si 4 bit no. Inizio sempre dal
fondo. Il ricevente calcola la parità di ogni cifra di controllo (queste ultime si trovano sempre
nelle potenze di 2 come posizione). Il ricevente calcola la sindrome posizionando le cifre di
controllo dalla più piccola (meno significativa) alla più grande (più significativa). Valgono zero
se la cifra ci controllo rispetta le parità e valgono 1 se la cifra di controllo non rispetta la parità.
Trasformando il numero binario in decimale ho la posizione in cui è avvenuto l’errore. La
ridondanza del codice di Hamming è R= 1+m/k circa 1+logn/k.
• Distanza di hamming: suppongo di avere un messaggio in n cifre binarie,
lavorando in {0,1} quindi gli elementi con cui lavoro sono vettori in n bit. {0,1}^n è uno spazio
vettoriale. Se sono R^n, con n cifre posso avere 2^n combinazioni, se n=3 queste combinazioni
possono essere intese come i vertici di un cubo. Considero un insieme di vertici come
combinazioni accettabili e posso vedere un errore come uno spostamento sugli spigoli del cubo.
La distanza fra messaggi validi deve essere almeno di 1. Se è 2 mi accorgo che è successo un
errore, se è 3 posso correggere l’errore con una buona probabilità di indovinare. Se la distanza è
4 posso correggere l’errore e capire da dove arriva. La distanza di Hamming è la distanza tra il
messaggio inviato e quello ricevuto. Il peso di Hamming invece è la distanza fra un vettore e il
vettore nullo. Posso creare una bolla con al centro il messaggio corretto e ai lati, sulla superficie
della bolla, i messaggi errati. Se un errore sposta il messaggio su un valore sulla superficie della
bolla il ricevente lo sostituisce con il valore al centro della bolla. La bolla è definita come b(x,
r)= {y appartiene {0,1}^n | d(y,x) <=r}. Se voglio calcolare quante sfere ci stanno nel mio
spazio faccio vol totale/ vol sfera>= numero max sfere. Ho che 2^n/n+1>= 2^k-> 2^m>= n+1.
quindi come nel codice di Hamming se voglio correggere un errore devo rispettare questa
disequazione. Per calcolare il volume della bolla ho b(x, 1)= 1 + n su 1= n+1-> se il raggio è 1.
b(x,2)= 1+ n su 1 + n su 2-> se il raggio è 2 ecc. La distanza di Hamming gode di 3 proprietà: a)
d(x, y)>=0 e d(x, y)=0 se e solo se x=y; b) d(x, y)=d(y, x); c) d(x, z)<= d(x, y)+d(y,z).
• Codifica sorgente: suppongo di avere una sorgente s con un alfabeto {s1, s2,
..sq}, ogni simbolo ha una probabilità {p1, p2, pq} di uscire e l’obiettivo è quello di
rappresentare con un alfabeto i simboli emessi dalla sorgente. Per codifica intendiamo una
funzione y: S-> lamda*. Un tipo di codice è quello a blocchi ( conviene quando le pi sono simili
tra loro) in cui i simboli più frequenti hanno una code word più corta e simboli rari ne hanno
una più lunga. L’obiettivo è sempre quello di minimizzare la lunghezza media L= sommatoria
pi*li. Per capire quando termina una code word devo imporre 2 condizioni: 1) codice univoco (2
simboli non possono essere trasformati nella stessa code word), 2) nessuna sequenza può essere
mappata in modo che sia mal interpretata.
• N-esima estensione di S: l’n-sima estensione di S è un insieme di simboli di s, si
indica con S^n si ha che si= (si1, si2, sin). S^n contiene q^n simboli.
• Codici istantanei: sono codici in cui il ricevente riconosce subito le code word
ricevute, senza dover aspettare ke arrivi tutto il messaggio. Il concetto è che nessuna code-word
può essere prefisso di un’altra. I codici a blocchi sono tutti istantanei. Un esempio di codice
istantaneo è il comma code. (lo 0 o 1 separa sempre un simbolo da un altro). Un codice
istantaneo è migliore di un altro se ha lunghezza media minore.
• Disuguaglianza di Kraft: suppongo di avere una sorgente S con simboli s1, s2, sq
che hanno una probabilità p1, p2, pq. L’obiettivo è quello di trovare codifiche di lunghezza l1,
l2, lq. Questa disuguaglianza mi dice se le lunghezze prese vanno bene o no. Condizione
necessaria e sufficiente affinché esista un codice istantaneo r-ario avente lunghezze l1, l2, lq è
che k= sommatoria 1/r^li <= 1. I codici istantanei hanno k<=1 sempre ma non è sempre vero il
viceversa. Proposizione 1: se k<=1 allora esiste un codice istantaneo con lunghezze l1, l2, lq.
• Disequazione di Mc-Millan: esiste un codice univocamente decodificabile con
lunghezze l1, l2, lq se e solo se vale k<=1. se voglio costruire un codice istantaneo con
lunghezza media L minima devo avere che se: p1>=p2>=pq allora deve essere l1<=l2<=lq.
Proposizione 2: se ogni nodo interno di un albero binario di decisione ha 2 figli, allora K=1.
Proposizione 3: generalizza la proposizione 2 con r figli. Ho sempre K=1. Se k<=1 significa che
c’è almeno un nodo interno che ha un solo figlio (binario). Inoltre deve sempre essere che lq-
1=lq altrimenti il codice non sarebbe efficiente.
• Codici di Huffman: sono codici usati per trovare un codice istantaneo con
lunghezza media minore (cioè efficiente). È un algoritmo gready e funziona in maniera quasi
ricorsiva. È composto da 2 fasi: 1. si prendono gli r simboli con probabilità minore, si crea una
sorgente che ha una probabilità data dalla somma delle 2, continuo così finchè ho r sorgenti. 2.
assegno ad ogni sorgente un valore e faccio la fase all’indietro. Si crea un codice istantaneo.
Dato che ci sono diverse possibili combinazioni devo scegliere quella che mi minimizza la
varianza. V= sommatoria (pi-L)^2. per diminuire la varianza devo mettere la somma delle due
sorgenti nella più alta posizione disponibile. Verifico che la lunghezza media diminuisce ed è la
più piccola. Se q è una potenza di 2 ottengo un codice a blocchi. Se è quasi una potenza di 2,
ottengo un codice a blocchi accorciato. Un comma code ha tutti i simboli per cui vale p>=2/3
sommatoria pk. Huffman è un algoritmo per la compressione lossless. La varianza diminuisce se
metto la somma dei simboli più in alto possibile.
• Sorgenti di Markov: sono sorgenti dotate di memoria. Si chiama sorgente di
ordine m una sorgente che tiene conto degli ultimi m avvenimenti. La sorgente ha uno stato
interno. In totale una sorgente di ordine m ha qm stati. Si parla di probabilità condizionata. La
sorgente dovrebbe avere sempre uno stato di default. Se la sorgente non ha uno stato di default
ho una distribuzione di probabilità che mi dice con quale probabilità inizio nell’i-esimo stato.
Una sorgente può essere rappresentata come una matrice (nel nostro caso matrice 3x3).
Per trovare la probabilità che alla fine della computazione esca un simbolo moltiplico questa
matrice indicata con M per un vettore π=[pa,pb,pc]. Se voglio saperne la probabilità nella
seconda computazione faccio (π M) M = π M2.
I sistemi con una distribuzione stazionaria (non cambia mai) si chiamano ERGODICI e le
probabilità vengono ricavate dall’equazione π M = π.
TEOREMA: lim per n->infinito di Mijn=πj dove π è l’unica soluzione del sistema formato da
a) π M = π b) ∑πj=1 c) πj>0 [Mijn è la probabilità di trovarsi in uno stato j dopo n passi,
partendo dallo stato i]. La lunghezza media di un codice di Markov è solitamente minore della
lunghezza media di una sorgente senza memoria, cioè la compressione è migliore. In Markov la
lunghezza media si calcola come: L=pa La + pb Lb …. Con La=lunghezza media delle codeword
della prima riga etc.
• Codifica predittiva: considero una sorgente che emette un simbolo sn. Considero
un predittore P che cerca di “indovinare” il valore di sn. ln vale 1 se il predittore ha sbagliato e
vale 0 se il predittore ha indovinato. Il predittore ha in ingresso en per cercare di migliorare nel
caso in cui stia sbagliando molto.
Sul canale viene spedito en e il ricevente ha lo stesso predittore del mittente. Il ricevente calcola
sn facendo lo xor tra bn ed en. Il segnale viene inoltre compresso con i logaritmi: si invia cioè il
numero di zeri successivi. Esempio 00000100011001  spedisce 5302.
La probabilità di indovinare un simbolo è espressa come p e deve essere < ½. Per rappresentare
i numeri da spedire uso k bit. Ho quindi 2k numeri rappresentabili. Una di queste configurazioni
è usata per comunicare che seguiranno altri zeri. Con p(n) intendo la probabilità di avere una
sequenza di n zeri seguiti da un 1. {p(n)}s apparten No è una distribuzione di probabilità. ∑1infin
p(n)=∑pn q= q ∑pn= q (1/1-p)= 1. La lunghezza media dei bit che vengono trasmessi è : k/(1-
p2k-1). La lunghezza media e la varianza dipendono da p.
 • Tabelle di Hash: suppongo di codificare un codice sorgente. Uso una tabella di
1024 elementi e una funzione h: {0,1}n  {0,….,1023}. Quando incontro una nuova variabile
la inserisco all’interno della tabella. Quest’ultima deve essere creata in modo che 2 nomi diversi
abbiano 2 diverse corrispondenze. Le tabelle di hash possono essere viste come codifiche.
• Codice di Gray è un codice con distanza di Hamming pari a 1. Ho 3 bit, scrivo
tutti i valori per 2 bit 2 volte, poi aggiungo lo 0 in testa al primo gruppo e 1 in testa al secondo
gruppo, cioè:
2 bit  00 01 11 10 3 bit  000 001 011 010 100 101 111 110
Per passare da gray a binario copio i bit fino al primo 1 (compreso) poi nego tutti i bit fino al
prossimo 1.
• Codice di anti-gray: è un codice che da una parola all’altra cambia il numero max di bit. Se un
codice anti-grey ha lunghezza k, il codice grey ha lunghezza k-1. Scrivo le codeword con k=2,
di ogni parola faccio il negato e poi aggiungo 0 a quelle iniziali, 1 a quelle negate.
• Informazione ed entropia suppongo che da una sorgente sia uscito il simbolo si, I(si)=1/pi. Più è
alta la probabilità e meno informazioni vengono date. Dato che I(si,sj)=1/(pi pj) non va bene,
introduco la nuova formula I(si)=log(1/pi). Esiste un’altra funzione sensata per I(p) che gode
delle seguenti proprietà: 1)I(p) >=0 2)I(p1;p2)=I(p1)+I(p2) 3)I(p) deve essere una funzione
continua. L’entropia è l’informazione media di una sorgente  Hr(s)= ∑i=1q pi I(si). Per p=1/e
l’entropia assume valore massimo.
• Disuguaglianza di Gibbs: considero 2 distribuzioni di probabilità (x1,x2,….,xq) e (y1,y2,….,yq).
La diseguaglianza di Gibbs parte dal concetto che ln(x) <= x-1 per ogni x ed è: ∑i=1q xi
logr(yi/xi)<=0. L’uguaglianza vale solo se ho yi=xi per ogni i, quindi se le due distribuzioni sono
identiche. Questa disuguaglianza mi permette di dire che Hr(s) – logr q <=0  Hr(s)<= logr q.
Quindi la sorgente che ci da più informazioni è quella che genera i numeri casualmente. Questa
osservazione è in contraddizione con il concetto di informazione generico(un libro con lettere
casuali contiene meno informazioni).
• Che legame c’è tra Kraft e l’entropia? Hr(s)<=L
• Codifica di Shannon-Fano: suppongo di conoscere le probabilità pi dei simboli. L’obiettivo è
quello di creare un codice istantaneo. Non uso Huffman perché è troppo “lento”, non so dire
subito la lunghezza del simbolo. Quindi, conoscendo pi ho che logr (1/pi) <= li < logr (1/pi) + 1.
So che li è l’unico intero compreso nell’intervallo. Se vale la diseguaglianza di Kraft allora le li
sono state scelte “bene”. Devo trasformare le li in 1/rli, rlogr(1/pi) <= rli < rlogr(1/pi) + 1  1/pi <= r li <
r/pi  pi >= 1/rli > pi/r  ∑pi >= ∑ (1/rli) > ∑ (pi/r)  1>= ∑ (1/rli) > 1/r (la prima parte
dell’ultima diseguaglianza corrisponde alla dis. di Kraft).
Per capire da dove vengano le codeword devo ragionare sulla dimostrazione di Kraft. Ho che
Hr(s)<=L< Hr(s)+1. La lunghezza media del codice che ottengo è minore di Hr+1. Si discosta al
massimo di 1 dal valore ottimale. Shannon-Fano è buono.
• Primo teorema di Shannon-Fano: cosa succede quando considero l’n-esima estensione di una
sorgente? Ho qn simboli, calcolo l’entropia  Hr(sn)=n Hr(s) quindi Hr(sn)<=Ln< Hr(sn)+1 
nHr(s)<=Ln< n Hr(s)+1, concludo che Hr(s)<=(Ln/n)< Hr(s)+(1/n). Ogni codeword di codifica
usa n-upla di simboli
Mi avvicino all’ottimo ma devo codificare i …… (tagliato)
• Entropia per le sorgenti di Markov: Suppongo di avere una sorgente di markov di ordine
m. La probabilità di Si è P(Si|Si1,Si2,...Sim) cioè la probabilità condizionale. L'entropia della
sorgente è data da H(S|Si1..Sim)=Σs p(Si|si1..Sim) logr 1/(P(Si|si1..Sim)) considero le sorgenti
ergodiche e se considero la probabilitò di trovarmi in Si1,Si2,...Sim, definisco l'entropia come:
Hr(S)=Σs^m p(Si|si1..Sim) H(Si|si1..Sim)= Σs^m+1 p(Si1,Si2..Sim)logr 1/(P(Si|si1..Sim))
• Sistema aggiunto considero una sorgente di markov di ordine 1. definisco le probabilità
marginali come p(Si)= Σj p(Si,Sj) e p(Sj)=Σi p(Si,Sj). p(Sj,Si)= p(Sj) p(Si|Sj). Considero ΣS^2
p(Sj,Si)log2[(p(Si)p(Sj))/p(Sj,Si)] per la legge di Gibbs so che è <=0. [parte di dimostrazione]
 Considerando una sorgente S senza memoria ho che H(S)<=H(S). Quindi con gli stessi simboli
una sorgente con memoria offre una minore quantità di informazioni di una sorgente con
memoria. Se, i simboli sono stocasticamente indipendenti ho che H(S)=H(S)
• Canali, CBS e equazioni di canale: Di un canale devo considerare gli alfabeti in ingresso
(A=a1,a2,..aq) e in uscita (B=b1,b2,bs). A deve essere tale per cui A incluso in B, con una
distanza di hammming che ci permette di correggere gli errori. Uso una matrice di transazione
per il rumore, questa matrice è stocastica (le righe sono distribuzioni di probabilità). Suppongo
che il canale non possa creare o distruggere simboli. La matrice di transizione è stazionaria. Le
equazioni di canale ci dicono per ogni bj la probabilità che il bj stesso esca : p(bj)= Σ1q p(ai)p(bj|
ai). Scelgo cioè un qualunque simbolo ai e considero la probabilità che esca bj dopo questa ai.
Faccio il ragionamento x ogni i. Suppongo che nel canale non ci sia rumore, cioè che x ogni i
esiste uno e un solo j tale che p(bp|ai)=1. Se considero un canale completamente rumoroso ho in
uscita un simbolo casuale. Avrebbe quindi senso solo come generatore random:P(bj|ai)=1/S. Se
esce un bj qual'è la probabilità che sia stato inserito un simbolo ai? P(ai|bj)=(P(bj|ai)p(ai))/
(P(bj))=(P(bj|ai)p(ai))/Σ(P(bj|ai)p(ai)). Il canale binario simmetrico CBS è un canale con 0 e 1 in
ingresso e 0 e 1 in uscita. P è la probabilità di avere una trasmissione corretta e Q di avere una
trasmissione errata. La matrice di transazione è:
0 1
p 0 [P Q]
1-p 1[Q P]
le equazioni di canale sono
p(b=0)=pP+(1-p)Q; p(b=1)=pQ+(1-p)P. P(ai|bj): P(0|0)=Pp/(Pp+(1-p)Q); P(1|0)=Q(1-p)/(Pp+(1-
p)Q); P(0|1)=Qp/(Qp+(1-p)P); P(1|1)=P(1-p)/(Qp+(1-p)P); Se il canale è completamente rumoroso
ho che P=1/2 e Q=1/2. se non c'è rumore P=1 e Q=0. Il funzionamento corretto di un canale dipende
anche da come scelgo p e 1-p
• Entropia di un canale: posso misurare l'entropia delle sequenze in ingresso e uscita del
canale: Hr(A)=Σ1q p(ai)logr(1/p(ai)) e Hr(B)=Σ1S p(bj)logr(1/p(bj)). Definisco la quantità media
di informazione su A dopo l'uscita di un simbolo Bj Hr(A|Bj)=Σ1q p(ai|bj)logr(1/p(ai|bj)). Se ho
un qualunque simbolo in uscita avrò che l'entropia vale : Hr(A|B)=Σj=1S Σi=1q p(ai,bj)logr(1/p(ai|
bj))
Se ai e Bj sono stocasticamente indipendenti ho che p(ai,bj)=p(ai)p(bj) e Hr(A,B)=Hr(A)
+Hr(B). Se invece P(ai,bj)=p(ai) p(bj|ai) ho che Hr(A,B)=Hr(A)+Hr(B|A) si chiama
equivocazione è la quantità introdotta dal rumore. Se il canale è completamente rumoroso Hr(B|
A)=Hr(B) ho anche che Hr(A,B)=Hr(B,A)=Hr(B)+Hr(A|B).
• Mutua informazione: siamo nell'ottica di un osservatore all'uscita del canale. La mutua
informazione è data da I(ai,bj)=logr p(ai|bj)/p(bj). Se p(ai|bj)=p(ai)->I(ai, bj)=0 cioè il fatto che
sia uscito bj non ci dice niente sulla distribuzione di probabilità di ai. Questa è la condizione
ottima per la sicurezza. Se invece abbiamo p(ai|bj)>p(ai)->I(ai, bj)>0. I non può mai essere
minore di 0. Ai e bj possono essere scambiati cioè: I(bj,ai)=log(p(bj|ai)/p(bj). Ho che
I(ai;bj)<=I(ai). Per definire la mutua informazione del sistema possiamo calcolare le medie sugli
alfabeti. I(A;B)=I(B;A)= Σi=1qΣj=1S p(ai,bj) log(p(ai,bj)/p(ai)*p(bj). La mutua informazione
condizionata è data da I(ai,B)=Σj=1s p(bj|ai) I(bj;ai). La mutua informazione gode di alcune
proprietà: I(A,B)>=0. I(A;B)=0 Se A e B sono indipendenti . I(A;B)=I(B;A). Se combino la
mutua informazione con l'entropia ho che I(A;B)=H(A)+H(B)-H(A,B) quindi 0<=H(A|
B)<=H(A) 0<=H(B|A)<=H(B)
• Capacità di canale: è la quantità massima di informazione che transita nel canale. Uso la
mutua informazione per definirla. I(A;B)= ΣAΣB p(a,b)*logr p(a,b)/(p(a)p(b)).
Il problema è che le p(a) possono influire sulla mutua informazione, quindi scegliendo male p(a)
sfrutto male il canale. La capacità però non dipende da come usiamo noi il canale. Definisco
quindi la capacità come C=max I(A;B) (per ogni p(a)) cioè considero la mutua informazione per
ogni valore di p(a) con questo metodo però non conosco immediatamente le capacità.
In realtà i canali trattano tutti i simboli nello stesso modo. Se considero l'n-esima estensione di
un canale CBS quindi CBSn posso pensarla come n canali CBS messi in parallelo o in serie.
Canale uniforme:canale la cui matrice ha tutte le righe ricavabili dalle permutazioni della prima
riga. Le probabilità quindi non cambiano. Sono i canali più semplici da trattare.
Se considero un canale senza rumore ho che I(A,B)=Hr(B)=Hr(A). Come calcolo la capacità di
un canale binario simmetrico? Suppongo di avere pacchetti di bit che comprendono ciascuno un
bit di parità. Ho che I(A,B)=Hr(B)-W; W=ΣB P(b|a) logr1/p(b|a) -> I(A;B)=Hr(B)-n Hr(P)
Come calcolo la capacità di un CBS? Devo massimizzare Hr(B). Se indico con x la probabilità
che esca 0 e con 1-x la probabilità che esca 1 ho che per x=1/2 l'entropia ha il valore massimo.
La capacità di un CBS è quindi data da C=1-Hr(P)=1-Hr(Q). Se ho n canali in parallelo C=n
-CCBS=n(1-Hr(P))
• Teorema: calcola la capacità di un canale non simmetrico .
I(A;B)=ΣA p(a) ΣBp(B|A)log(p(b|a)/p(b))=ΣA p(a)I(a|B). Quando le p dei simboli di input mi
permettono di raggiungere la capacità di un canale allora abbiamo che: p(a)|I(A,B)=C->
I(a,B)=C