Aplicatii Tci
Aplicatii Tci
Aplicatii Tci
Panaitescu
Aplicatii la disciplina
TRANSMITEREA ŞI CODAREA
INFORMATIEI
1
2
CUVÂNT ÎNAINTE
Autorul
3
4
CUPRINSUL
SURSE DE INFORMATIE 18
Lucrarea 1
Tema 1: Entropia surselor de informatie fără memorie.
Tema 2: Entropia surselor duble de informatie
Lucrarea 2
Tema: Entropia surselor de informatie markoviene.
Lucrarea 3
Tema: Entropia surselor de informatie Markov binare.
Lucrarea 4
Tema: Transinformatia si capacitatea canalelor.
CRIPTAREA 67
Lucrarea 7
Tema 1: Criptarea RSA
Tema 2: Criptarea cu curbe eliptice
Lucrarea 8
Tema 1: Codurile Hamming (corectoare de o eroare)
Tema 2: Codul Hamming (7,4) în acţiune
5
6
APLICATII DIN TEORIA PROBABILITǍTILOR
Problema 1.
Problema 2.
7
ceea ce echivaleazǎ cu
1 + 1 – Pr(A ∩ B) – Pr( A ∪ B ) = 1,3 (de Morgan)
si apoi
1 + 1 – Pr(A ∩ B) – (1 – Pr(A ∪ B)) = 1,3 (probabilitatea contrarului)
si mai departe
Pr(A ∩ B) = 2 – (1 – 0,7) – 1,3 = 0,4
Revenind la prima formulǎ (si la a doua) se obtine
Pr(A∆B) = Pr(A) + Pr(B) – Pr(A ∩ B) – Pr(A ∩ B) =
= Pr(A ∪ B) – Pr(A ∩ B) = 0,7 – 0,4 = 0,3
Problema 3.
A B
8
a. Trebuie calculatǎ probabilitatea
P ( A ∩ B ∩ C ) = P( A ∪ B ∪ C ) = 1 − P ( A ∪ B ∪ C )
Dar probabilitatea
P(A ∪ B ∪ C) = P(A) + P(B) + P(C) – P(A ∩ B) – P(A ∩ C) – P(B ∩ C) +
+ P(A ∩ B ∩ C)
este deplin calculabilǎ din datele problemei.
b. Trebuie calculatǎ probabilitatea
P[(A – B ∪ C) ∪ (B – A ∪ C) ∪ (C – A ∪ B)]
pentru o reuniune de evenimente douǎ câte douǎ mutual incompatibile.
Rezultatul este suma probabilitǎtilor celor trei evenimente. Se evalueazǎ ca
exemplu una din ele
P ( A − B ∪ C ) = P[ A ∩ ( B ∪ C )] =
= P[ A ∩ ( B ∩ C )] = P( A ∩ B ∩ C ) = P ( A ∪ B ∪ C )
Calculul probabilitǎtii de mai sus trece prin relatia cunoscutǎ (si de la
punctul a.)
P( A ∪ B ∪ C) = P( A ) + P(B) + P(C) – P( A ∩ B) – P( A ∩ C) – P(B ∩ C) +
+ P( A ∩ B ∩ C)
Dar
P( A ∩ B) + P(A ∩ B) = P(B)
din motive de incompatibilitate mutualǎ a celor douǎ evenimente A ∩ B, A
∩ B si pentru cǎ ( A ∩ B) ∪ (A ∩ B) = B. În relatia ultimǎ existǎ un singur
termen necunoscut: P( A ∩ B).
Analog se evalueazǎ P( A ∩ C) si P( A ∩ B ∩ C) care, ca si P( A ∩ B) se
înlocuiesc în fromula pentru P ( A ∪ B ∪ C ) .
Rezultǎ imediat P ( A ∪ B ∪ C ) .
Asemǎnǎtor se evalueazǎ si ceilalti termeni din probabilitatea cerutǎ.
Problema 4.
Se aruncǎ douǎ zaruri, unul corect, altul incorect. Cel incorect are probabilitǎtile
fetelor 1, 2, 3, 4, 5, 6 nu egale ci în relatia P(1) = P(2) = P(3) = 2P(4) = 2P(5) =
2P(6). Fie X variabila aleatoare care ia valorile de pe zarul corect si Y variabila
aleatoare care ia valori conform zarului incorect.
a. Scrieti un program Matlab care sǎ genereze doi vectori x, y, fiecare cu câte
10.000 de elemente obtinute prin simularea variabilelor X respectiv Y.
b. Fie Z variabila aleatoare Z = X – Y. Valorile posibile ale lui Z sunt 0, ±1, ±2,
±3, ±4, ±5. Utilizati vectorul z = x – y si functia Matlab “mean” pentru a
aproxima probabilitǎtile P(Z = 0), P(Z = ±1), P(Z = ±2), P(Z = ±3), P(Z =
±4), P(Z = ±5). Faceti o diagramǎ P(Z = z) cu z în abscisǎ, pentru z = 0, ±1,
±2, ±3, ±4, ±5.
c. Fie S o secventǎ de 36 de perechi (i, j), cu i = 1, 2, 3, 4, 5, 6 valori ale
variabilei aleatoare X, cu j = 1, 2, 3, 4, 5, 6 valori ale variabilei aleatoare Y.
9
În altǎ exprimare X(i, j) = i, Y(i, j) = j pentru oricare din perechile (i, j) ∈ S.
Fie evenimentul Z = 4. Scrieti toate rezultatele (i, j) care formeazǎ
evenimentul Z = 4. Calculati prin rationament probabilitatea P(Z = 4) si
comparati cu aproximarea pentru P(Z = 4) obtinutǎ la punctul b. prin
Matlab.
Solutie. Mai întâi, dacǎ fetele zarului corect sunt echiprobabile, toate fetele
având aceeasi probabilitate de 1/6, la zarul incorect se rezolvǎ ecuatia 2x + 2x +
2x + x + x + x = 1 din care rezultǎ probabilitǎtile pentru fiecare fatǎ: 2/9, 2/9,
2/9, 1/9, 1/9, 1/9, respectiv pentru Y = 1, 2, 3, 4, 5, 6.
a. Aici se scrie programul Matlab. Nu sunt dificultǎti majore.
b. Probabilitǎtile cerute se evalueazǎ prin inventarierea efectivǎ a
cazurilor. De pildǎ, Z = ±4 se obtine în cazul perechilor (1, 5’), (2, 6’) (5,
1’) si (6, 2’) (cifrele fǎrǎ accent sunt obtinute pe zarul corect, cele cu accent
pe zarul incorect). Probabilitǎtile perechilor sunt respectiv (1/6)(1/9), (1/6)
(1/9), (1/6)(2/9), (1/6)(2/9) ca produs de probabilitǎti ale unor evenimente
independente. Probabilitatea P(Z = ±4) este suma acestor probabilitǎti
(perechile enumerate sunt mutual incompatibile), adicǎ 1/9. La fel se
calculeazǎ si alte probabilitǎti cerute prin enunt.
c. La acest punct se recomandǎ iarǎsi apelul la facilitǎtile Matlab-ului.
Problema 5.
Fie o secventǎ de date {x1, x2, …, xn} în care fiecare xi provine din multimea {1,
2, 3, 4}. Din aceste date se poate construi un asa-numit model predictiv care
constǎ în 16 probabilitǎti conditionate p(j/i), i, j = 1, 2, 3, 4 calculate în modul
descris mai jos. Pentru fiecare pereche (i, j) fie N(i) numǎrul de întregi 1 ≤ m ≤
n – 1 pentru care xm = i, si fie N(i, j) numǎrul de întregi 1 ≤ m ≤ n – 1 astfel
încât (xm, xm+1) = (i, j). Probabilitatea conditionatǎ cǎutatǎ este
N (i, j )
p( j / i) =
N (i )
a. Fie x o secventǎ de date pseudoaleatoare de lungime 1000 generatǎ de
urmǎtorul script Matlab:
a=0; b=0;
x=[ ];y=[ ];
for i=1:1000
sample=ceil(4*rand(1,1));
if sample==1
w1=0;w2=1;w3=1;w4=1;
elseif sample==2
w1=1;w2=0;w3=1;w4=1;
elseif sample==3
w1=1;w2=1;w3=0;w4=1;
else
w1=1;w2=1;w3=1;w4=0;
end
if a+w3<b+w4
10
xtemp=[x 1];
else
xtemp=[y 2];
end
if a+w1<b+w2
xtemp=[x 3];
else
xtemp=[y 4];
end
x=xtemp;
y=ytemp;
atemp=min(a+w1,b+w2);
btemp=min(a+w3,b=w4);
a=atemp;
b=btemp;
end
Problema 6.
11
Problema 7.
A 1 B
1 2
A B
12
Problema 9.
Se dau douǎ cutii. Cutia 1 contine 10 cǎrti din care 3 sunt marcate fiecare cu
numǎrul “1” si celelalte 7 sunt narcate cu numǎrul “2”. Cutia 2 contine 15 cǎrti
din care 9 sunt marcate cu “1”, iar restul de 6 sunt marcate cu “2”.
Se executǎ urmǎtorul experiment aleator, în trei pasi. La pasul 1 se alege aleator
echiprobabil o cutie si apoi se alege aleator o carte din acea cutie; numǎrul de
pe carte (1 sau 2) este înregistrat – sǎ-i spunem numǎrul N1. La pasul 2, se alege
la întâmplare o carte din cutia N1 si numǎrul de pe carte este notat – fie acesta
N2. La pasul 3 se alege tot aleator din cutia N2 si numǎrul de pe carte se noteazǎ
– fie acela N3. Se considerǎ ca spatiu al esantioanelor pentru acest experiment
multimea tuturor valorilor triple (N1, N2, N3). Sunt 8 rezultate posibile în spatiul
esantioanelor. Folositi teorema multiplicǎrii ca ajutor în a calcula probabilitatea
fiecǎruia din cele 8 rezultate, în cazurile urmǎtoare:
a. În cazul când cartea este totdeauna pusǎ înapoi în cutia din care a fost aleasǎ
înainte de alegerea unei alte cǎrti.
b. În cazul când o carte este totdeauna pusǎ înapoi, dar în cealaltǎ cutie.
c. Sǎ presupunem cǎ primul caz (a.) prevaleazǎ. Calculati probabilitǎtile Pr(N3
= 1) si Pr(N3 = 2).
Problema 10.
13
Problema 11.
Mary, Bill si Joe joacǎ jocul urmǎtor cu o monedǎ corectǎ (cel ce pierde dǎ un
rând de beri): mai întâi Mary aruncǎ moneda – dacǎ obtine cap câstigǎ jocul;
altminteri Bill aruncǎ si el moneda – dacǎ obtine cap câstigǎ jocul; altminteri
Joe aruncǎ si el moneda – dacǎ obtine cap câstigǎ jocul. Dacǎ nimeni nu câstigǎ
jocul la primul tur de aruncǎri se procedeazǎ la alte tururi identice cu primul
pânǎ când cineva câstigǎ jocul.
a. Fie Z o variabilǎ aleatoare geometricǎ cu parametrul p = 1/2. Stabiliti o
partitie de întregi pozitivi în trei submultimi E1, E2, E3 astfel încât
probabilitǎtile evenimentelor {Z ∈ E1}, {Z ∈ E2}, {Z ∈ E3} sǎ mǎsoare
sansele ca jocul sǎ fie câstigat de Mary, de Bill, respectiv de Joe.
b. Calculati probabilitǎtile ca Mary sǎ câstige jocul, ca Bill sǎ câstige jocul, ca
Joe sǎ câstige jocul (respectiv) uzând de distributia geometricǎ.
Afisati sub formǎ de tabel cele 14 valori ale functiei de repartitie FX(x)
pentru x = 0, 1, 2, …, 13. Calculati probabilitatea Pr(X > 2) printr-o singurǎ
cǎutare în tabel. Calculati probabilitatea Pr(2 ≤ X ≤ 5) prin numai douǎ
cǎutǎri în tabel.
b. Executati programul Matlab urmǎtor pentru a genera un vector cu primele
18 valori ale functiei de repartitie a variabilei aleatoare Y distribuitǎ dupǎ o
lege Poisson cu parametrul λ = 5,7.
lambda=5.7;
s(1)=1;
for k=1:17
s(k+1)=lambda*s(k)/k;
end
y=exp(-lambda)*s;
cdf_values=cumsum(y);
14
Afisati sub formǎ de tabel cele 18 valori ale functiei FY(y) pentru y = 0, 1, 2,
…, 17. Calculati probabilitatea Pr(X ≥ 4) printr-o singurǎ cǎutare în tabel.
Calculati probabilitatea Pr(2 < X < 5) prin numai douǎ cǎutǎri în tabel.
Problema 13.
15
Problema 16.
Problema 17.
f R (r ) =
0 în rest
Media si dispersia sunt date de relatiile E[R] = π / 2 , Var[R] = 2 – π/2.
a. Dacǎ U este o variabilǎ aleatoare uniform distribuitǎ între 0 si 1, stabiliti o
transformare R = φ(U) astfel încât R sǎ aibǎ densitatea de probabilitate fR(r).
b. Utilizând transformarea de la punctul a., scrieti un program Matlab simplu
care sǎ genereze un vector de 10.000 observatii simulate ale valorilor lui R.
Utilizati functiile Matlab mean si var pe vectorul generat pentru a obtine
estimatii ale mediei E[R] si dispersiei Var[R] date mai sus. Sunt estimǎrile
obtinute estimǎri bune?
c. Se cunoaste cǎ dacǎ variabilele aleatoare X, Y sunt repartizate normal cu
media 0 si dispersia 1, atunci R = X 2 + Y 2 are densitatea de probabilitate
fR(r). Uzând de acest fapt, scrieti un alt program simplu Matlab care sǎ
genereze un vector de 10.000 de observatii simulate asupra lui R. Utilizati
functiile Matlab mean si var pe vectorul generat pentru a obtine estimatii
ale mediei E[R] si dispersiei Var[R] date mai devreme. Probabil aceste
estimǎri vor fi cam aceleasi cu cele de la punctul b.
16
E[D2] = E[D2|D = 0]Pr(D = 0) + E[D2|D > 0]Pr(D > 0)
17
SURSE DE INFORMATIE
Lucrarea 1
18
clear
n=8; % numarul de simboluri ale sursei
if n>15
n=15;
end % o limitare a numarului de simboluri
if n<2
n=2;
end % o alta limitare a numarului de simboluri
simb=1:n; % simbolurile sursei
prob=(1/n)*ones(1,n);
entropia_maxima=entropie(prob)
prob=rand(1,n); % generarea a n numere aleatoare intre 0 si 1
prob=prob/sum(prob); % normaliarea listei de n numere; suma =
1
simboluri=simb
probabilitati=prob
h=entropie(prob);
entropia_efectiva=h
redundanta_sursei=entropia_maxima-entropia_efectiva
display('*** Uremaza o egalizare a probabilitatilor a doua
simboluri ***')
display('*** Pentru continuare apasati Enter! ***')
pause
r=ceil(n*rand(1,2)) % se genereaza doua numere de la 1 la n
med=(prob(r(1))+prob(r(2)))/2; % se mediaza probabilitatile
prob(r(1))=med;
prob(r(2))=med;
simboluri=simb
probabilitati=prob
h=entropie(prob);
entropia_noua=h
display('*** Uremaza o reducere a numarului de simboluri ***')
display('*** Pentru continuare apasati Enter! ***')
pause
prob(n-1)=prob(n-1)+prob(n); % se pun laolalta ultimele doua
simboluri
simboluri=simboluri(1:(n-1))
probabilitati=prob(1:(n-1))
h=entropie(prob(1:(n-1)));
entropia_noua=h
display('*** Uremaza adaugarea unui simbol cu probabilitate nula
***')
display('*** Pentru continuare apasati Enter! ***')
pause
prob(n)=0; % se adauga un simbol cu probabilitatea nula
simboluri=[simboluri n]
probabilitati=prob
h=entropie(prob);
entropia_noua=h
function entropie=ent(s)
% s este vectorul (linie) al probabilitatilor
[n,m]=size(s);
ent=0;
19
for i=1:m
if s(i)>0
ent=ent-s(i)*log(s(i));
end
end
ent=ent/log(2);
entropie=ent;
clear
m=7;
n=5; % se alege numarul simbourilor generate de cele doua
surse
proa=rand(1,m); % generarea a m numere aleatoare intre 0 si 1
proa=proa/sum(proa); % normaliarea listei de m numere; suma =
1
prob=rand(1,n); % generarea a n numere aleatoare intre 0 si 1
prob=prob/sum(prob); % normaliarea listei de n numere; suma =
1
disp(' ')
s='Surse independente, probabilitati, entropii';
disp(s)
20
A=proa
B=prob
a=entropie(proa); % entropia sursei A
b=entropie(prob); % entropia sursei B
Entropii=[a b]
Suma_entropiilor=a+b % suma entropiilor
prod=proa'*prob; % probabilitatile perechilor (a,b), A, B
independente
AXB=prod
for i=1:m
entrl(i)=entropie(prod(i,:));
end
entropie_AXB=sum(entrl) % entropia sursei duble AXB, A, B
independnete
disp(' ')
s='Surse dependente, probabilitati, entropii';
disp(s)
cond=rand(m,n);
for i=1:m
cond(i,:)=cond(i,:)/sum(cond(i,:));
end % generarea probabilitatilor conditionate P(b/a)
disp(' ')
s='Matricea de conditionare b/a';
disp(s)
cond
for i=1:n
prod(:,i)=proa'.*cond(:,i);
end % calculul probabilitatilor pe perechi (a,b), A, B
dependente
prob=sum(prod); % calculul probabilitatilor pentru sursa B
B=prob
b=entropie(prob) % entropia sursei B
Entropii=[a b]
Suma_entropiilor=a+b % suma entropiilor
AXB=prod
for i=1:m
entrl(i)=entropie(prod(i,:));
end
entropie_AXB=sum(entrl) % entropia sursei duble AXB, A, B
independente
Lucrarea 2
21
Se generează aleator o matrice a probabilitătilor de tranzitie din cele n stări în
cele n stări ale sursei. Matricea p nu poate fi decât pătrată, n×n, cu suma liniilor
egală cu unitatea.
Starea initială s a sursei este precizată uzual printr-un vector (linie) de
probabilităti, cu suma componentelor egală cu 1. În program, starea initială
poate fi modificată în linia/liniile unde ea este definită, marcată si ea cu un
comentariu. Starea initială, ca si oricare altă stare ulterioară este caracterizată de
o entropie care este evaluată cu functia entropie reprodusă într-un listing
aparte, la finalul acestor câteva pagini de îndrumare. Functia entropie nu este
altceva decât transcrierea în Matlab a formulei binecunoscute pentru entropia
unei surse simple (fără memorie).
Înainte de prima pauză în executia programului, se afisează matricea de
tranzitie, starea initială si entropia corespunzătoare.
Apoi se simulează o evolutie a sursei (10 pasi). De regulă, sursa evoluează către
o stare stationară. Se afisează stările succesive si entropiile asociate. Se poate
observa o convergentă către o stare numită si stare stationară. Această stare nu
este explicită, este numai bănuită din evolutia sursei. Lucrurile devin ceva mai
clare dacă se extinde evolutia la mai mult de 10 pasi, prin modificarea limitei
superioare a instructiunii “for k=1:10”.
După următoarea pauză în executie se calculează efectiv starea stationară.
Rezultatele afisate diferă întrucâtva de ultima stare din secventa evolutivă
anterioară. De regulă, starea stationară este descrisă printr-un vector de
probabilităti cu toate componentele nenule. Se zice în aceste cazuri că sursa este
ergodică. Uneori, un vector al unei stări stationare contine componente nule
(stări excluse pe termen lung) sau o componentă unitară si celelalte nule (stări
absorbante). Aceste situatii caracterizează surse neergodice.
Se recomandă executarea repetată a programului, cu acelasi număr n de stări
sau cu valori ale lui n diferite. A se observa evolutia sursei, stările si entropiile
asociate, starea stationară.
clear
n=4; % numarul de stari ale sursei
if n>8
n=8;
end % o limitare a numarului de stari
if n<2
n=2;
end % o alta limitare a numarului de stari
p=rand(n);
for i=1:n
suml=sum(p(i,:));
p(i,:)=p(i,:)/suml;
end % crearea unei matrici a tranzitiilor
matricea_tranzitiilor=p
s=zeros(1,n);
s(2)=1; % starea initiala
starea_initiala_si_entropia=[s entropie(s)]
display('*** Uremaza o evolutie a sursei Markov (10 pasi) ***')
22
display('*** Pentru continuare apasati Enter! ***')
pause
for k=1:10
s=s*p;
starea_curenta_si_entropia=[s entropie(s)]
end
display('*** Uremaza calculul starii stationare a sursei Markov
***')
display('*** Pentru continuare apasati Enter! ***')
pause
a=p-eye(n);
a=a';
ap=zeros(n-1);
for i=1:n
k=0;
for j=1:n
if j~=i
k=k+1;
ap(1:(n-1),k)=a(2:n,j);
end
end
compl(i)=(-1)^i*det(ap);
end % evaluarea starii stationare
s=compl/sum(compl); % probabilitatile starii stationare
starea_stationara=s
starea_stationara=s*p % verificarea starii stationare
starea_stationara_si_entropia=[starea_stationara entropie(s)]
function entropie=ent(s)
% s este vectorul (linie) al probabilitatilor
[n,m]=size(s);
ent=0;
for i=1:m
if s(i)>0
ent=ent-s(i)*log(s(i));
end
end
ent=ent/log(2);
entropie=ent;
Lucrarea 3
23
Se generează aleator o matrice a probabilitătilor de tranzitie din cele n stări în
cele n stări ale sursei. Matricea p nu poate fi decât pătrată, n×n, cu suma liniilor
egală cu unitatea. Multe elemente în această matrice pot fi si chiar sunt nule. De
fapt, pe fiecare linie numai două elemente sunt nenule deoarece numai două
tranzitii sunt posibile, din starea de plecare în numai alte două stări care se obtin
prin deplasarea spre stânga a expresiei binare a stării curente si înlocuirea
ultimului bit cu 0 sau 1. De pildă, din starea curentă 101 nu se poate ajumge
decât în stările 010 sau 011 (s-a subliniat de fiecare dată partea rămasă din
expresia binară a stării curente după deplasarea la stânga cu pierderea primului
bit). O trecere din starea 101 în alte stări, de pildă în starea 110, nu este posibilă
într-un singur pas.
Starea initială s a sursei este precizată printr-un vector (linie) de probabilităti,
cu suma componentelor egală cu 1. În program, starea initială poate fi
modificată în linia/liniile unde ea este definită, marcată dealtfel cu un
comentariu. Starea initială, ca si oricare altă stare ulterioară este caracterizată de
o entropie care este evaluată cu functia entropie, dată si ea în listingul
alăturat. Functia aceasta nu este altceva decât transcrierea în Matlab a formulei
binecunoscute pentru entropia unei surse simple (fără memorie).
Înainte de prima pauză în executia programului, se afisează matricea de
tranzitie, starea initială si entropia corespunzătoare.
Apoi se simulează o evolutie a sursei (10 pasi). De regulă, sursa evoluează către
o stare stationară. Se afisează stările succesive si entropiile asociate. Se poate
observa o convergentă către o stare numită si stare stationară. Această stare nu
este explicită, este numai bănuită din evolutia sursei. Lucrurile devin ceva mai
clare dacă se extinde evolutia la mai mult de 10 pasi, prin modificarea limitei
superioare pentru k în instructiunea “for k=1:10”.
După următoarea pauză în executie se calculează efectiv starea stationară.
Rezultatele afisate diferă întrucâtva de ultima stare din secventa evolutivă
anterioară. De regulă, starea stationară este descrisă printr-un vector de
probabilităti cu toate componentele nenule. Se zice în aceste cazuri că sursa este
ergodică. Uneori, un vector al unei stări stationare contine componente nule
(stări excluse pe termen lung) sau o componentă unitară si celelalte nule (stări
absorbante). Aceste situatii caracterizează sursele neergodice.
Se recomandă executarea repetată a programului, pentru surse de acelasi ordin
sau de ordine diferite. A se observa evolutia sursei, stările si entropiile asociate,
starea stationară.
clear
ordin=2; % ordinul sursei
n=2^ordin; % numarul de stari ale sursei
if n>16
n=16;
end % o limitare a numarului de stari
if n<2
n=2;
end % o alta limitare a numarului de stari
24
for i=1:n
s=dec2bin(i-1,ordin);
stari(i,:)=s;
starin(i)=i-1;
end
stari
p=zeros(n);
for i=1:n
m=mod(2*(i-1),n);
m1=m;
m2=mod(m+1,n);
p(i,m1+1)=rand;
p(i,m2+1)=rand;
end
for i=1:n
suml=sum(p(i,:));
p(i,:)=p(i,:)/suml;
end % crearea unei matrici a tranzitiilor
matricea_tranzitiilor=p
s=zeros(1,n);
s(1)=1; % starea initiala
starea_initiala_si_entropia=[s entropie(s)]
display('*** Uremaza o evolutie a sursei Markov (10 pasi) ***')
display('*** Pentru continuare apasati Enter! ***')
pause
for k=1:10
s=s*p;
starea_curenta_si_entropia=[s entropie(s)]
end % evolutia sursei
display('*** Uremaza calculul starii stationare a sursei Markov
***')
display('*** Pentru continuare apasati Enter! ***')
pause
a=p-eye(n);
a=a';
ap=zeros(n-1);
for i=1:n
k=0;
for j=1:n
if j~=i
k=k+1;
ap(1:(n-1),k)=a(2:n,j);
end
end
compl(i)=(-1)^i*det(ap);
end % evaluarea starii statinare
s=compl/sum(compl); % probabilitatile starii stationare
starea_stationara=s
starea_stationara=s*p % verificarea starii stationare
starea_stationara_si_entropia=[starea_stationara entropie(s)]
function entropie=ent(s)
% s este vectorul (linie) al probabilitatilor
[n,m]=size(s);
25
ent=0;
for i=1:m
if s(i)>0
ent=ent-s(i)*log(s(i));
end
end
ent=ent/log(2);
entropie=ent;
Problema 19.
O monedǎ perfectǎ este aruncatǎ succesiv pânǎ apare prima stemǎ. Fie X
numǎrul de aruncǎri necesare.
a. Aflati entropia H(X) în biti. Expresiile urmǎtoare pot fi utile în evaluarea
cerutǎ:
∞ ∞
r r
∑n= 1 r n = 1 − r , ∑n= 1 nr n = (1 − r ) 2
b. Potrivit acestei scheme se genereazǎ o variabilǎ aleatoare X. Stabiliti o
secventǎ eficientǎ de întrebǎri cu rǎspunsuri da-nu, de forma “Este X
continut în multimea S?”. Comparati H(X) cu numǎrul mediu de întrebǎri
necesare pentru a determina X.
Solutie.
a. La prima aruncare, probabilitatea de a încheia experimentul este 1/2.
Probabilitatea de a încheia experimentul la a doua aruncare este 1/4.
Probabilitatea de a obtine prima oarǎ stemǎ la a n-a aruncare este (1/2)n.
Variabila aleatoare X este de tip discret cu probabilitǎtile asociate
numerelor naturale egale cu puterile succesive ale lui 1/2. Entropia cerutǎ
este datǎ de formula
∞ ∞ n
1 1 1/ 2
H(X) = ∑ n log 2 n = ∑ n = = 2
n= 1 2 n= 1 2 (1 − 1 / 2) 2
b. Ideea este a obtine maximum de informatie la fiecare întrebare. Fie a un
numǎr care partitioneazǎ prin ordine (n ≤ a, n > a) multimea numerelor
naturale în multimea S si multimea N – S. Întrebarea “Este X continut în
k
1 1
multimea S?” poate avea rǎspunsul “da” cu probabilitatea ∑ n = 1 − k ,
n= 1 2 2
∞
1 1
“nu” cu probabilitatea ∑ n = k (a – 1 < k ≤ a).
n= k + 1 2 2
Informatia medie obtinutǎ la o întrebare de acest gen este
1 1 1 1
− 1 − k log 1 − k − k log k
2 2 2 2
etc.
26
Problema 20. Regula grupǎrii pentru entropie.
Problema 21.
27
Solutia acestei probleme rezidă în a determina de la caz la caz dacă este vorba
sau nu de o aplicatie bijectivă. De observat că bijectivitatea se referă exclusiv la
suportul variabilei X, adică la acele valori x pentru care p(x) > 0.
a. Y = X 5 este o bijectie, asadar entropia este o functie numai de parobabilităti
(si nu de valorile rezultatelor observate) si de aceea nu se schimbă: H(X) =
H(Y).
b. Y = X 2 este o functie pară si, în consecintă, nu este o corespondentă
biunivocă cu exceptia cazului în care suportul variabilei X nu contine
simultan valori x si opusele lor – x.
c. Ca si la punctul a., Y = tgX este o bijectie (ca functie pe întregi) si H(X) =
H(Y).
În general, pentru punctul b., H(Y) ≤ H(X). Pentru acest caz este posibil a se da
o margine superioară pentru H(X): deoarece X poate lua numai două valori la
orice Y dat, H(X|Y) ≤ log2 = 1. Asadar
H(Y) ≤ H(X) = H(X, Y) = H(Y) + H(X|Y) ≤ H(Y) + 1
28
Una din cele n monede este mai usoară;
Toate au aceeasi greutate.
Fiecare cântărire poate avea unul din trei rezultate posibile: egalitate, talerul
din stânga mai greu sau talerul din dreapta mai greu. În k operaţii de
cântărire, sunt posibile 3k rezultate ceea ce face posibilă distincţia între cel
mult 3k “stări” diferite. Asadar, 2n + 1 ≤ 3k, sau n ≤ (3k – 1)/2.
Din punct de vedere al informaţiei, fiecare cântărire aduce cel mult log23
biti de informatie. Sunt 2n + 1 “stări” posibile, cu un maxim de entropie de
log2(2n + 1) biti. În consecinţă, în această situaţie sunt necesare cel puţin
log2(2n + 1)/log23 cântăriri pentru a extrage suficientă informatie despre
moneda falsă. Se observă, rezultatul este acelasi ca acela de mai devreme.
b. Această problemă cunoaste mai multe abordări posibile. Una din ele se
bazează pe sistemul de numeratie ternar.
Numerele {–12, –11, …, –1, 0, 1, …, 12} se pot exprima într-un sistem de
numeratie ternar cu alfabetul {–1, 0, 1}. De pildă numărul 8 este (–1)01
deoarece (–1)×30 + 0×31 + 1×32 = 8. Se formează o matrice cu coloanele
reprezentând numere pozitive
1 2 3 4 5 6 7 8 9 10 11 12
30 1 –1 0 1 –1 0 1 –1 0 1 –1 0 Σ1 = 0
31 0 1 1 1 –1 –1 –1 0 0 0 1 1 Σ2 = 2
32 0 0 0 0 1 1 1 1 1 1 1 1 Σ3 = 8
1 2 3 4 5 6 7 8 9 10 11 12
3 0
1 –1 0 1 –1 0 –1 –1 0 1 1 0 Σ1 = 0
31 0 1 1 1 –1 –1 1 0 0 0 –1 –1 Σ2 = 0
32 0 0 0 0 1 1 –1 1 –1 1 –1 –1 Σ3 = 0
29
exemplu, 0(–1)(–1) conduce la 0×30 + (–1)×31 + (–1)×32 = –12 ceea ce
indică moneda numărul 12 ca fiind mai grea, 10(–1) indică moneda numărul
8 ca fiind mai usoară, 000 indică absenta monedei cu defect.
De ce această schemă lucrează? Ea este un cod Hamming corector de o
eroare pentru alfabetul ternar (v.capitolul dedicat subiectului). Urmează
câteva detalii.
De observat mai întâi câteva proprietăţi ale matricii de mai sus care este
folosită în schemă. Toate coloanele sunt distincte si nici o pereche de
coloane adunate nu dau vectorul nul. Totodată, dacă o monedă este mai
grea, ea va produce secventa de cântăriri care se potriveste cu coloana ei din
matrice. Dacă moneda este mai usoară, produce ca secventă de cântăriri
negativa coloanei ei. Prin combinarea tuturor acestor fapte, se poate vedea
că orice monedă (unică) diferită ca greutate va produce o secventă de
cântăriri (unică) si moneda poate fi determinată din acea secventă.
Una din întrebările care se pot formula este dacă limita stabilită la punctul
(a) este realmente accesibilă. De pildă, se pot tria 13 monede prin trei
cântăriri? Desi nu se poate cu o schemă ca aceea de mai sus, se poate în
ipoteza în care s-a extras limita de mai devreme. Limita nici nu interzice
împărtirea monedelor în două submultimi, nici nu exclude existenta unei
alte monede cunoscută ca normală. În oricare din aceste condiţii, este
posibil a găsi moneda diferită dintre cele 13 prin 3 cântăriri.
Y
0 1
X
0 1/3 1/3
1 0 1/3
Stabiliti:
a. H(X) si H(Y)
b. H(Y|X) si H(X|Y)
c. H(Y, X)
d. H(Y) – H(Y|X)
Solutie:
a. H(X) = (2/3)log(3/2) + (1/3)log3 ≈ 0,918 biti. Aceeasi entropie pentru Y.
b. H(X|Y) = (1/3)H(X|Y = 0) + (2/3)H(X|Y = 1) ≈ 0,667 biti. Rezultat identic si
pentru H(Y|X).
c. H(X,Y) = 3(1/3)log3 ≈ 1,585 biti.
d. H(Y) – H(Y|X) ≈ 0,251 biti.
30
Problema 26.
Problema 27.
Problema 28.
Fie X si Y douǎ variabile aleatoare care iau valorile x1, x2, …, xr, respectiv y1, y2,
…, ys si fie Z = X + Y.
a. Sǎ se verifice prin calcul direct cǎ H(Z/X) = H(Y/X). Pe baza acestui fapt,
argumentati cǎ dacǎ X si Y sunt independente, atunci H(Y) ≤ H(Z).
(Indicatie: informatia este totdeauna nenegativǎ)
b. Dati un exemplu în care H(X) > H(Z) si H(Y) > H(Z). (Indicatie: încercati sǎ
faceti H(Z) = 0)
c. În ce conditii are loc relatia H(Z) = H(X) + H(Y)?
Problema 29.
Arǎtati cǎ entropia pentru distributia probabilisticǎ (p1, …, pi, …, pj, …, pm) este
mai redusǎ decât cea a distributiei (q1, …, qm) în care qi = qj = (pi + pj)/2 si qk =
pk pentru orice k diferit de i si j. (Indicatie: calculati Hp – Hq uzând de relatia de
definitie). Observati cǎ acest rezultat particular este legat de un adevǎr general:
împingerea unei distributii spre uniformitate are ca efect cresterea entropiei.
Solutie. Entropia sursei în forma originarǎ este
m
H p = − ∑ p k log p k
k= 1
Entropia sursei modificate este
m
H q = − ∑ q k log q k
k=1
În cele douǎ sume cei mai multi termeni sunt identici si anume aceia de indice k
diferit de i si de j. Asadar, diferenta celor douǎ entropii este
(p + pj) (p + pj)
Hq − H p = − 2 i log i + pi log pi + p j log p j =
2 2
31
1 1 1 1 1 1
= 2 − pi + pi log pi + pi − − pi log pi − p j log p j
2 2 2 2 2 2
Pe baza convexitǎtii functiei –xlogx, rezultǎ pozitivitatea diferentei. Ceea ce
trebuia demonstrat.
Problema 31.
32
b. Maximizati în raport cu α pentru a arăta că 2 H ( X ) ≤ 2 H ( X 1 ) + 2 H ( X 2 ) si
interpretati utilizând notiunea după care 2H(X) este dimensiunea efectivă a
alfabetului.
c. Fie X1 si X2 distribuite uniform pe multimile lor alfabetice. Care este
valoarea α care maximizează entropia H(X) asociată.
Solutie:
a. Această problemă poate fi rezolvată prin scrierea relatiei de definitie a
entropiei si prin dezvoltarea termenilor diversi pe care aceasta în contine.
Dar aici se utilizează algebra legată de entropii pentru o demonstratie mai
simplă. Deoarece X1 si X2 au multimi de definitie disjuncte, se poate scrie
X cu probabilitatea α
X= 1
X 2 cu probabilitatea 1 − α
Se defineste o functie de X
1 pentru X = X 1
θ = f (X ) =
2 pentru X = X 2
Apoi, ca în problema 1,
H(X) = H(X,f(X)) = H(θ) + H(X|θ) =
= H(θ) + p(θ = 1)H(X|θ = 1) + p(θ = 2)H(X|θ = 2) =
= H(α) + αH(X1) + (1 – α)H(X2)
cu H(α) = – αlogα – (1 – α)log(1 – α).
b. Punând F(α) = H(α) + αH(X1) + (1 – α)H(X2), se observă că F este o functie
concavă de a asa încât ea este maximă în punctul de anulare a derivatei.
Rezolvând
F’(α) = – logα + log(1 – α) + H(X1) – H(X2) = 0
se obtine succesiv
2H ( X1 )
α * = H ( X1 )
2 + 2H ( X 2 )
( )
F (α * ) = log 2 H ( X 1 ) + 2 H ( X 2 ) .
Asadar,
H(X) = H(α) + αH(X1) + (1 – α)H(X2) = F(α) ≤ F (α ) = log 2 1 + 2 2 (* H(X )
)
H(X )
În final,
2H ( X ) ≤ 2H ( X1 ) + 2H ( X 2 )
c. Deoarece X1 si X2 sunt uniforme pe multimile lor alfabetice, entropiile lor
sunt date de cardinalele acestor multimi. Astfel, H(X1) = log|X1| = logm si
H(X2) = log|X2| = log(n – m). Prin înlocuirea acestor valori în expresia lui α*
de la punctul anterior, se obtine
2H ( X1 ) 2log m m m
α * = H ( X1 ) = log( n − m )
= =
2 + 2 H(X2 )
2 log m
+ 2 m + ( n − m) n
33
Aflati densitatea de maximǎ entropie f care satisface relatiile EX = α1, Elnx =
α2. În altǎ formulare, stabiliti
max{h(f)}
în conditiile
∫ xf ( x)dx = α 1 , ∫ (ln x) f ( x)dx = α 2
Ce familie de densitǎti de probabilitate este aceasta?
Solutie. Distributia de maximǎ entropie supusǎ la restrictiile din enunt este de
forma
f ( x) = e λ 0 + λ 1x + λ 2 ln x = cx λ 2 e λ 1x
care face parte din familia distributiilor Gamma. Constantele se aleg pentru a
satisface relatiile restrictive.
O pasăre zboară din încăpere în încăpere într-un cub 3×3×3 (egal probabil prin
fiecare perete interior). Care este rata entropiei?
Solutie: Rata entropiei unei deplasări aleatoare (random walk) într-un graf este
dată de relatia
E E
H ( X ) = log(2 E ) − H 1 ,..., m
2E 2E
Un cub are 8 vârfuri, 12 muchii, 6 fete si un centru. Vârfurile au 3 arce,
muchiile au 4 arce, fetele au 5 arce si centrele au 6 arce. Asadar numărul total
de arce este E = 54. Astfel,
3 3 4 4
H (X ) = log108 + 8 log + 12 log +
108 108 108 108
5 5 6 6
+ 6 log + 1 log = 2,03 biti.
108 108 108 108
34
Graful 1 Graful 2 Graful 3
La pasul k, se alege unul din cele k – 1 noduri terminale potrivit unei distributii
uniforme si se dezvoltă acel nod. Se continuă până când se generează n noduri
terminale. Astfel, o secventă care conduce la cinci noduri poate arăta astfel:
35
Surprinzător, metoda următoare de generare de arbori aleatori produce aceeasi
distributie probabilistică pe arbori cu n noduri terminale. Mai întâi se alege un
întreg N1 uniform distribuit pe multimea {1, 2, …, n}. Se obtine imaginea:
N1 n – N1
N1 N1 – N2 N3 n – N1 – N3
36
sau
H n H n− 1
= + cn
n n− 1
cu adaosul cn potrivit definit. Deoarece Σcn = c < ∞, s-a dovedit prin aceasta că
H(Tn)/n tinde către o constantă. Astfel, numărul mediu statistic de biti necesari
pentru a descrie arborele aleator Tn creste liniar cu n.
Solutie:
Prin conditionarea în lant a entropiilor si pentru că N1 este o functie de Tn,
H(Tn,N1) = H(Tn) + H(N1|Tn) = H(Tn) + 0.
Prin conditionarea în lant a entropiilor, H(Tn,N1) = H(N1) + H(Tn|N1).
H(N1) = log(n – 1) deoarece N1 este uniform pe {1, 2, …, n – 1}.
Prin definitia entropiei conditionate,
n− 1
1 n− 1
H (Tn | N1 ) = ∑ p ( N1 = k ) H (Tn | N1 = k ) = ∑ H (Tn | N1 = k )
k=1 n − 1 k=1
Deoarece conditionat de N1, subarborele din stânga si subarborele din dreapta
sunt alegeri independente, H(Tn|N1 = k) = H(Tk,Tn – k|N1 = k) = H(Tk) + H(Tn – k)
asa încât
1 n− 1
H (Tn | N1 ) = ∑ [ H (Tk ) + H (Tn − k )]
n − 1 k=1
Printr-o simplă schimbare de variabile,
n− 1 n− 1
∑
k=1
H (Tn − k ) = ∑
k=1
H (Tk )
37
Hn ∞
2 log(i − 2) ∞
2 log(i − 1) ∞
2
lim n → ∞
n
= ∑
i= 3 i (i − 1)
≤ ∑ i= 3 (i − 1) 2
= ∑
i= 2 i
2
log i
Se dă matricea
1 / 2 1 / 4 1 / 4
P = [ Pij ] = 1 / 4 1 / 2 1 / 4
1 / 4 1 / 4 1 / 2
Fie X1 distribuit uniform pe stările {0, 1, 2}. Fie {Xi}1∞ un lanţ Markov cu
matricea de tranzitie P, astfel încât Pr(Xn + 1 = j|Xn = i) = Pij, i, j ∈ {0, 1, 2}.
a. Este {Xn} stationar?
b. Aflati limn → ∞ H(X1, …, Xn).
Considerati acum procesul derivat Z1, Z2, …, Zn în care
Z1 = X1
Zi = Xi – Xi – 1 (mod 3), i = 2, 3, …, n
Asadar, Zn face o codare a tranzitiilor, nu a stărilor.
c. Aflati H(Z1, Z2, …, Zn).
d. Aflati H(Zn) si H(Xn) pentru n ≥ 2.
e. Aflati H(Zn|Zn – 1) pentru n ≥ 2.
f. Sunt, pentru n ≥ 2, Zn – 1 si Zn independente?
Solutie:
a. Fie µn functia de probabilitate la momentul n. Deoarece µ1 = (1/3, 1/3, 1/3)
si µ2 = µ1P = µ1, µn = µ1 = (1/3, 1/3, 1/3) pentru orice n si {Xn} este
stationar.
Alternativ, observatia că P este dublu stochastică conduce la aceeasi
concluzie.
b. Deoarece {Xn} este un proces Markov stationar
2
lim n → ∞ H ( X 1 ,..., X n ) = H ( X 2 | X 1 ) = ∑
k= 0
P( X 1 = k ) H ( X 2 | X 1 = k ) =
1 1 1 1 3
= 3⋅
⋅ H , , =
3 2 4 4 2
c. Deoarece secventele (X1, …, Xn) si (Z1, …, Zn) sunt în corespondentă
biunivocă, prin regula conditionărilor succesive ale entropiilor si din
markovianism
38
n
H(Z1, …, Zn) = H(X1, …, Xn) = ∑k=1
H ( X k | X 1 ,..., X k − 1 ) =
n
3
= H ( X1) + ∑
k= 2
H ( X k | X k − 1 ) = H ( X 1 ) + (n − 1) H ( X 2 | X 1 ) = log 3 +
2
(n − 1)
39
Alternativ, se poate ataca direct rata entropiei unui proces Markov de ordinul 2
{Xn} astfel
1 1 n
lim n → ∞ H ( X n ) = lim n → ∞ ∑ H ( X i | X i − 1 ) =
n n i= 1
1 n
= lim n → ∞ ∑ H ( X i | X i − 1, X i − 2 ) → H ( p)
n i= 1
în ultima egalitate se evidentiază ordinul procesului, 2, iar limita provine din
faptul că H ( X n | X n − 1 , X n − 2 ) = H ( p ) pentru orice n ≥ 3 (Cesáro).
Lucrarea 4
40
Tema: Transinformatia si capacitatea canalelor.
41
În program s-a preferat numai o explorare a limitei pentru transinformatie prin
generarea aleatoare a mai multor surse cu n simboluri si prin evaluarea de
fiecare dată a informatiei mutuale. Se poate observa o cea-mai-mare-valoare a
transinformatiei între aceste “realizări” posibile, care se apropie de capacitatea
canalului.
clear
n=3;
m=4;
p=rand(n,m);
for i=1:n
suml=sum(p(i,:));
p(i,:)=p(i,:)/suml;
end % crearea unei matrici a canalului
matricea_canalului=p
a=rand(1,n);
a=a/sum(a); % probabilitati sursa de intrare
b=a*p; % probabilitati sursa observata la iesire
probabilitatile_simbolurilor_de_intrare=a
ha=entropie(a); % entropia apriori
entropia_apriori=ha
probabilitatile_simbolurilor_de_iesire=b
hb=entropie(b);
entropia_sursei_observate_la_ieisre=hb
pab=zeros(n,m);
for i=1:n
for j=1:m
pab(i,j)=p(i,j)*a(i)/b(j);
end
end
probabilitati_intrare_condiditionate_de_iesiri=pab
for j=1:m
enap(j)=entropie((pab(:,j))');
end % entropii aposteriori
entropii_aposteriori=enap
entropia_conditionata_de_iesirea_observata=b*enap'
transinformatia=ha-b*enap'
display('*** Uremaza o cautare aleatoare a capacitatii canalului
***')
display('*** Pentru continuare apasati Enter! ***')
pause % cautarea aleatoare a capacitatii canalului
for k=1:20
a=rand(1,n);a=a/sum(a);b=a*p;
ha=entropie(a);
for i=1:n
for j=1:m
pab(i,j)=p(i,j)*a(i)/b(j);
end
end
for j=1:m
enap(j)=entropie((pab(:,j))');
end
sursa_la_intrare_si_transinformatia=[a ha-b*enap']
42
end
Problema 39.
Problema 40.
Problema 41.
Se considerǎ un canal cu alfabet binar care preia simboluri de doi biti si produce
la iesire simboluri de doi biti conform asocierii urmǎtoare: 00 → 01, 01 → 10,
10 → 11 si 11 → 00. Astfel, dacǎ secventa de doi biti 01 este introdusǎ în
canal, iesirea este 10 cu probabilitatea 1. Fie X1, X2 douǎ simboluri la intrare si
Y1, Y2 simbolurile de iesire corespunzǎtoare.
Calculati informatia mutualǎ I(X1, X2 ; Y1, Y2) ca functie de distributia la intrare
a celor patru perechi de intrare posibile.
Arǎtati cǎ pentru transmiterea în perechi capacitatea acestui canal este de 2 biti.
Arǎtati cǎ la maximizare prin distributia la intrare, I(X1 ; Y1) = 0.
43
Asadar, distributia secventelor de intrare care atinge capacitatea canalului nu
maximizeazǎ în mod necesar informatia mutualǎ între simboluri individuale si
corespunzǎtoarele lor la iesire.
1–p
0 0
p
p
1 1
1–p
1
2 2
44
1 p 1− p 0 0 1
2 0 p 1− p 0 2
X Y
3 0 0 p 1 − p 3
4 1− p 0 0 p 4
1 p 1− p 0 1
X2 0 p 1 − p 2 Y ?
3 1 − p 0 p 3
Comparati informatia mutuală I(X; Y1, Y2) pe care (Y1, Y2) o furnizează despre X,
cu suma informatiilor mutuale I(X; Y1) si I(X; Y2) pentru fiecare din cele două
functii de probabilitate de mai departe.
a. Două priviri independente:
45
p(x, y1, y2) = p(x)p(y1|x)p(y2|x)
b. O privire la două observatii independente:
p(x, y1, y2) = p(y1)p(y2)p(x|y1, y2)
Solutie:
a. Două priviri independente:
I(X; Y1, Y2) = H(Y1, Y2) – H(Y1,Y2|X) =
= [H(Y1) + H(Y2) – I(Y1;Y2)] – H(Y1,Y2|X) =
= [H(Y1) + H(Y2) – I(Y1;Y2)] – [H(Y1|X) + H(Y2|X)] =
= I(X;Y1) + I(X;Y2) – I(Y1;Y2) ≤ I(X;Y1) + I(X;Y2)
În succesiunea de relatii de mai sus s-au utilizat: relatia de definitie a
informatiei mutuale, formula pentru calculul entropiei surselor compuse,
absenta conditionării între Y1 si Y2 când este dat X si nenegativitatea informatiei
mutuale.
b. O privire la două observatii independente:
I(X; Y1, Y2) = H(Y1, Y2) – H(Y1,Y2|X) =
= [H(Y1) + H(Y2)] – H(Y1,Y2|X) =
= [H(Y1) + H(Y2)] – [H(Y1|X) + H(Y2|X) – I(Y1;Y2|X)] =
= I(X;Y1) + I(X;Y2) + I(Y1;Y2|X) ≥ I(X;Y1) + I(X;Y2)
Aici s-au folosit: relatia de definitie a informatiei mutuale, independenta între
Y1 si Y2, identitatea pentru entropia H(Y1,Y2|X), din nou relatia de definitie a
informatiei mutuale si nenegativitatea informatiei mutuale.
1 2 3
46
b. Fie Xi(n) numǎrul de cǎi valide de lungime n cu finalul în starea i.
Argumentati cǎ X(n) = [X1(n) X2(n) X3(n)]T verificǎ relatia de recurentǎ de
mai jos:
X 1 (n) 0 1 1 X 1 (n − 1)
X 2 (n) = 1 0 0 X 2 (n − 1) = AX(n − 1)
X (n) 0 1 0 X (n − 1)
3 3
T
cu conditia initialǎ X(1) = [1 1 0] .
c. Apoi, prin inductie are loc
X(n) = AX(n – 1) = A2X(n – 2) = … = An–1X(1)
Utilizând descompunerea lui A dupǎ valorile proprii, pentru cazul valorilor
proprii distincte, se poate scrie A = U –1ΛU, cu Λ matricea diagonalǎ a
valorilor proprii. Atunci An–1 = U –1Λn–1U. Arǎtati cǎ se poate scrie
n− 1
X(n) = λ 1n − 1 Y1 + λ n2− 1 Y2 + λ 3 Y3
în care Y1, Y2, Y3 nu depind de n. Pentru n mare, aceastǎ sumǎ este
dominatǎ de termenul cel mai mare. Demonstrati cǎ pentru i = 1, 2, 3 are loc
1
log X i (n) → log λ
n
cu λ valoarea proprie (pozitivǎ) ce mai mare. Astfel, pentru n mare,
numǎrul de secvente de lungime n creste ca λn. Calculati λ pentru matricea
A de mai sus (cazul în care valorile proprii nu sunt distincte poate fi
manipulat în mod similar).
d. Se abordeazǎ acum o tratare diferitǎ. Se considerǎ lantul Markov cu
diagrama de stare datǎ la punctul a. dar cu probabilitǎtile tranzitiilor
arbitrare. Prin urmare matricea de tranzitie a lantului Markov este
0 α 1
P = 1 0 0
0 1 − α 0
Arǎtati cǎ distributia stationarǎ a lantului Markov este
T
1 1 1− α
µ =
3 − α 3 − α 3 − α
e. Maximizati rata entropiei lantului Markov în raport cu α. Care este entropia
maximǎ a lantului?
f. Comparati rata maximǎ a entropiei obtinutǎ la punctul e. cu log λ de la
punctul c. De ce cele douǎ rǎspunsuri sunt identice?
47
Z
X=±A + Y=X+Z
48
CODAREA PENTRU CANALE FĂRĂ PERTURBATII
Lucrarea 5.
clear
n=15; % numarul de simboluri ale sursei
if n>15
n=15;
end % o limitare a numarului de simboluri
if n<2
n=2;
end % o alta limitare a numarului de simboluri
simb=1:n; % simbolurile sursei
prob=rand(1,n); % generarea a n numere aleatoare intre 0 si 1
prob=prob/sum(prob); % normaliarea listei de n numere; suma=1
%prob=(1/n)*ones(1,n); % prin decomentare, probabilitatile se
fac egale
i=zeros(n,n);
lun=i;
num=i;
y=i;
[y(1,:),i1]=sort(prob,'descend'); % ordonarea probabiltatilor
for j=1:n
49
simb1(j)=simb(i1(j));
end
simboluri=simb
probabilitati=prob
simboluri_ordonate=simb1
probabilitati_ordonate=y(1,:)
i(1,:)=1:n;
for j=2:(n-1)
y(j,:)=y(j-1,:);
y(j,n-j+1)=y(j-1,n-j+2)+y(j-1,n-j+1);
y(j,n-j+2)=0;
[y(j,1:(n-j+1)),i(j,1:(n-j+1))]=sort(y(j,1:(n-
j+1)),'descend');
end % secventa directa a algoritmului Huffman
lun(n-1,1)=1;lun(n-1,2)=1;
num(n-1,1)=0;num(n-1,2)=1;
for j=(n-1):(-1):2
[l,m]=max(i(j,:));
%[l m]
i2=0;
for k=1:(n-j+1)
if k~=m
i2=i2+1;
lun(j-1,i2)=lun(j,k);
num(j-1,i2)=num(j,k);
end
end
lun(j-1,l)=lun(j,m)+1;
lun(j-1,l+1)=lun(j,m)+1;
num(j-1,l)=2*num(j,m);
num(j-1,l+1)=2*num(j,m)+1;
end % secventa inversa a algoritmului Huffman
lungimi_cuvinte_de_cod=lun(1,:) % afisarea lungimilor
cuvintelor de cod
cuvinte_de_cod='';
for j=1:n
cuvinte_de_cod=[cuvinte_de_cod,'
',dec2bin(num(1,j),lun(1,j))];
end
cuvinte_de_cod % afisarea cuvintelor de cod Huffman
entropia_sursei=-y(1,:)*log((y(1,:))')/log(2) % entropia
sursei
lungimea_medie_a_codului=lun(1,:)*(y(1,:))' % lungimea medie
a codului
Se selectează un fisier de un tip anumit. Numele lui (si calea dacă este cazul)
sunt înlocuite în linia a doua a programului. În varianta alăturată, este trecut
50
sirul 'TCI5.doc' care presupune că fisierul este în acelasi folder/director cu
programul.
Se citeste fisierul ales ca o succesiune de octeti (bytes). Se face statistica
fisierului considerat sursă de informatie, sursă de simboluri ASCII
corespunzătoare unor numere de la 0 la 255. Frecventele relative sunt
considerate probabilităti. Fisierul este considerat “fără memorie’.
Se aplică algoritmul Huffman care duce la alocarea unor cuvinte de cod fiecărui
cod ASCII.
Se calculează lungimea medie a codului, se calculează eficienta codului.
Se recomandă executarea programului pentru mai multe fisiere de acelasi tip
(aceeasi extensie), pentru fisiere de tipuri variate. Se compară eficienta
codurilor în cazurile studiate, se compară si cu eficienta comprimării fisierelor
cu programele de comprimare comerciale.
clear
idf=fopen('TCI5.doc'); % se creaza un identificator pentru
fisierul ales
[a,n]=fread(idf); % se citeste fisierul ca o secventa de n
bytes
st=fclose(idf); % se inchide fisierul
p=zeros(256,256);
f=zeros(1,256);iper=f;
for i=1:n % se calculeaza frecventele absolute
f(a(i)+1)=f(a(i)+1)+1;
end
sf=sum(f);
f=f/sf; % se calculeaza frecventele relative
h=0; % se calculeaza entropia
for i=1:256
if f(i)>0
h=h-f(i)*log(f(i));
end
end
h=h/log(2);
% incepe comprimarea Huffman
[y,in]=sort(-f);
p(:,1)=-y';
for k=2:255 % se realizeaza "redusele" (parcursul
direct)
z=p(258-k,k-1)+p(257-k,k-1);
p(257-k,k)=z;
p(258-k,k)=0;
p(1:256-k,k)=p(1:256-k,k-1);
[y,inc]=sort(-p(:,k));
p(:,k)=-y;
ina=(1:256)';
iper(k)=1;
for i=1:257-k % se localizeaza simbolul rezultat din alte
doua
if ina(i)==inc(i)
iper(k)=i+1;
51
end
iper(k)=min(iper(k),257-k);
end
end
% parcursul invers
lcod=zeros(256,1);
lcod(1)=1;lcod(2)=1;nc=1;
for k=254:(-1):1
nc=nc+1;
lcper=lcod(iper(k+1));
for i=1:nc
if i>iper(k+1)
lcod(i-1)=lcod(i);
end
end
lcod(nc)=lcper+1;
lcod(nc+1)=lcod(nc);
end
lmed=lcod'*p(:,1);
'Entropia si lungimea medie a codului (biti):',h,lmed
'eficienta codului (%):',efi=100*h/lmed
#ifndef __ARITHMETICCODERC_H__
#define __ARITHMETICCODERC_H__
#include <fstream>
52
using namespace std;
class ArithmeticCoderC
{
public:
ArithmeticCoderC();
void SetFile( fstream *file );
void Encode( const unsigned int low_count,
const unsigned int high_count,
const unsigned int total );
void EncodeFinish();
void DecodeStart();
unsigned int DecodeTarget( const unsigned int total );
void Decode( const unsigned int low_count,
const unsigned int high_count );
protected:
// bit operations
void SetBit( const unsigned char bit );
void SetBitFlush();
unsigned char GetBit();
unsigned char mBitBuffer;
unsigned char mBitCount;
// in-/output stream
fstream *mFile;
// encoder & decoder
unsigned int mLow;
unsigned int mHigh;
unsigned int mStep;
unsigned int mScale;
// decoder
unsigned int mBuffer;
};
#endif
#include "ArithmeticCoderC.h"
#include "tools.h"
// constante pentru divizarea spatiului de numere intregi
// reprezentabile pe 32 biti
// bitul cel mai semnificativ este mentinut liber pentru
// a preveni depasirile
const unsigned int g_FirstQuarter = 0x20000000;
const unsigned int g_ThirdQuarter = 0x60000000;
const unsigned int g_Half = 0x40000000;
ArithmeticCoderC::ArithmeticCoderC()
{
mBitCount = 0;
mBitBuffer = 0;
mLow = 0;
mHigh = 0x7FFFFFFF;
// se lucreaza cu 31 de biti, cei mai putin semnificativi
mScale = 0;
mBuffer = 0;
mStep = 0;
53
}
void ArithmeticCoderC::SetFile( fstream *file )
{
mFile = file;
}
void ArithmeticCoderC::SetBit( const unsigned char bit )
{
// se adauga un bit la buffer
mBitBuffer = (mBitBuffer << 1) | bit;
mBitCount++;
if(mBitCount == 8) // bufferul plin
{
// scriere
mFile-
>write(reinterpret_cast<char*>(&mBitBuffer),sizeof(mBitBuffer));
mBitCount = 0;
}
}
void ArithmeticCoderC::SetBitFlush()
{
// se umple bufferul cu zerouri pana la urmatorul byte
while( mBitCount != 0 )
SetBit( 0 );
}
unsigned char ArithmeticCoderC::GetBit()
{
if(mBitCount == 0) // bufferul gol
{
if( !( mFile->eof() ) ) // fisierul citit complet?
mFile-
>read(reinterpret_cast<char*>(&mBitBuffer),sizeof(mBitBuffer));
else
mBitBuffer = 0; // se ataseaza zerouri
mBitCount = 8;
}
// se extrage un bit din buffer
unsigned char bit = mBitBuffer >> 7;
mBitBuffer <<= 1;
mBitCount--;
return bit;
}
void ArithmeticCoderC::Encode( const unsigned int low_count,
const unsigned int high_count,
const unsigned int total )
// total < 2ˆ29
{
// se partitioneaza spatiul numerelor in pasi unici
mStep = ( mHigh - mLow + 1 ) / total;
// interval deschis superior => +1
// se actualizeaza limita superioara
mHigh = mLow + mStep * high_count - 1;
// interval deschis superior => -1
// se actualizeaza limita inferioara
mLow = mLow + mStep * low_count;
54
// se aplica scalari E1/E2
while( ( mHigh < g_Half ) || ( mLow >= g_Half ) )
{
if( mHigh < g_Half )
{
SetBit( 0 );
mLow = mLow * 2;
mHigh = mHigh * 2 + 1;
// se executa scalari E3
for(; mScale > 0; mScale-- )
SetBit( 1 );
}
else if( mLow >= g_Half )
{
SetBit( 1 );
mLow = 2 * ( mLow - g_Half );
mHigh = 2 * ( mHigh - g_Half ) + 1;
// se executa scalari E3
for(; mScale > 0; mScale-- )
SetBit( 0 );
}
}
// E3
while( ( g_FirstQuarter <= mLow ) && ( mHigh <
g_ThirdQuarter ) )
{
// se retin scalarile E3 necesare
mScale++;
mLow = 2 * ( mLow - g_FirstQuarter );
mHigh = 2 * ( mHigh - g_FirstQuarter ) + 1;
}
}
void ArithmeticCoderC::EncodeFinish()
{
// exista doua posibilitati de distribuire pentru mLow and
// mHigh, ceea ce inseamna ca doi biti sunt suficienti pentru
// a le deosebi
if( mLow < g_FirstQuarter )
// mLow < FirstQuarter < Half <= mHigh
{
SetBit( 0 );
for( int i=0; i<mScale+1; i++ ) // se executa scalarea E3
SetBit(1);
}
else // mLow < Half < ThirdQuarter <= mHigh
{
SetBit( 1 );
// zerouri adaugate automat de decodor;
// nu este necesar a le trimite
}
// se goleste bufferul de iesire
SetBitFlush();
}
void ArithmeticCoderC::DecodeStart()
55
{
// se umple bufferul cu biti din fluxul de intrare
for( int i=0; i<31; i++ )
// se utilizeaza numai 31 de biti, cei mai putin semnificativi
mBuffer = ( mBuffer << 1 ) | GetBit();
}
unsigned int ArithmeticCoderC::DecodeTarget( const unsigned int
total )
// total < 2ˆ29
{
// se partitioneaza spatiul numerelor in pasi unici
mStep = ( mHigh - mLow + 1 ) / total;
// interval deschis superior => +1
// se returneaza valoarea curenta
return ( mBuffer - mLow ) / mStep;
}
void ArithmeticCoderC::Decode( const unsigned int low_count,
const unsigned int high_count )
{
// se actualizeaza limita superioara
mHigh = mLow + mStep * high_count - 1;
// interval deschis superior => -1
// se actualizeaza limita inferioara
mLow = mLow + mStep * low_count;
// scalare E1/E2
while( ( mHigh < g_Half ) || ( mLow >= g_Half ) )
{
if( mHigh < g_Half )
{
mLow = mLow * 2;
mHigh = mHigh * 2 + 1;
mBuffer = 2 * mBuffer + GetBit();
}
else if( mLow >= g_Half )
{
mLow = 2 * ( mLow - g_Half );
mHigh = 2 * ( mHigh - g_Half ) + 1;
mBuffer = 2 * ( mBuffer - g_Half ) + GetBit();
}
mScale = 0;
}
// scalare E3
while( ( g_FirstQuarter <= mLow ) && ( mHigh <
g_ThirdQuarter ) )
{
mScale++;
mLow = 2 * ( mLow - g_FirstQuarter );
mHigh = 2 * ( mHigh - g_FirstQuarter ) + 1;
mBuffer = 2 * ( mBuffer - g_FirstQuarter ) + GetBit();
}
}
56
#ifndef __MODELI_H__
#define __MODELI_H__
#include "ArithmeticCoderC.h"
enum ModeE
{
MODE_ENCODE = 0,
MODE_DECODE
};
class ModelI
{
public:
void Process( fstream *source, fstream *target, ModeE mode );
protected:
virtual void Encode() = 0;
virtual void Decode() = 0;
ArithmeticCoderC mAC;
fstream *mSource;
fstream *mTarget;
};
#endif
#include "ModelI.h"
void ModelI::Process( fstream *source, fstream *target, ModeE
mode )
{
mSource = source;
mTarget = target;
if( mode == MODE_ENCODE )
{
mAC.SetFile( mTarget );
// codare
Encode();
mAC.EncodeFinish();
}
else // MODE_DECODE
{
mAC.SetFile( mSource );
mAC.DecodeStart();
// decodare
Decode();
}
};
#ifndef __MODELORDER0C_H__
#define __MODELORDER0C_H__
#include "ModelI.h"
class ModelOrder0C : public ModelI
{
57
public:
ModelOrder0C();
protected:
void Encode();
void Decode();
unsigned int mCumCount[ 257 ];
unsigned int mTotal;
};
#endif
#include "ModelOrder0C.h"
ModelOrder0C::ModelOrder0C()
{
// se initializeaza probabilitatile cu 1
mTotal = 257; // 256 + simbolul escape pentru incheiere
for( unsigned int i=0; i<257; i++ )
mCumCount[i] = 1;
}
void ModelOrder0C::Encode()
{
while( !mSource->eof() )
{
unsigned char symbol;
// se citeste un simbol
mSource->read( reinterpret_cast<char*>(&symbol),
sizeof( symbol ) );
if( !mSource->eof() )
{
// frecventele de cumuleaza
unsigned int low_count = 0;
for( unsigned char j=0; j<symbol; j++ )
low_count += mCumCount[j];
// se codeaza simbolul
mAC.Encode( low_count, low_count + mCumCount[j], mTotal );
// se actualizeaza modelul
mCumCount[ symbol ]++;
mTotal++;
}
}
// se scrie simbolul escape pentru incheiere
mAC.Encode( mTotal-1, mTotal, mTotal );
}
void ModelOrder0C::Decode()
{
unsigned int symbol;
do
{
unsigned int value;
// se citeste o valoare
value = mAC.DecodeTarget( mTotal );
unsigned int low_count = 0;
// se determina simbolul
58
for( symbol=0; low_count + mCumCount[symbol] <= value; symbol+
+ )
low_count += mCumCount[symbol];
// se scrie simbolul
if( symbol < 256 )
mTarget->write( reinterpret_cast<char*>(&symbol), sizeof( char )
);
// se adapteaza decodorul
mAC.Decode( low_count, low_count + mCumCount[ symbol ] );
// se actualizeaza modelul
mCumCount[ symbol ]++;
mTotal++;
}
while( symbol != 256 );
// pana la citirea simbolului de incheiere
}
A.7 Tools
#ifndef __TOOLS_H__
#define __TOOLS_H__
int inline min( int a, int b )
{
return a<b?a:b;
};
#endif
A.8 Main
#include <iostream>
#include <fstream>
using namespace std;
#include "ModelOrder0C.h"
// signature: "ACMC" (0x434D4341, intel byte order)
// (magic number for recognition of encoded files)
const int g_Signature = 0x434D4341;
int __cdecl main(int argc, char *argv[])
{
cout << "Arithmetic Coding" << endl;
if( argc != 3 )
{
cout << "Syntax: AC source target" << endl;
return 1;
}
fstream source, target;
ModelI* model;
// se alege modelul, aici tocmai modelul de ordinul 0
model = new ModelOrder0C;
source.open( argv[1], ios::in | ios::binary );
target.open( argv[2], ios::out | ios::binary );
if( !source.is_open() )
{
cout << "Cannot open input stream";
59
return 2;
}
if( !target.is_open() )
{
cout << "Cannot open output stream";
return 3;
}
unsigned int signature;
source.read(reinterpret_cast<char*>(&signature),sizeof(signature
));
if( signature == g_Signature )
{
cout << "Decoding " << argv[1] << " to " << argv[2] << endl;
model->Process( &source, &target, MODE_DECODE );
}
else
{
cout << "Encoding " << argv[1] << " to " << argv[2] << endl;
source.seekg( 0, ios::beg );
target.write( reinterpret_cast<const char*>(&g_Signature),
sizeof(g_Signature) );
model->Process( &source, &target, MODE_ENCODE );
}
source.close();
target.close();
return 0;
}
60
Ultimii doi termeni însumati produc un rezultat maximal atunci când α = 0,
adică atunci când cele două simboluri sunt echiprobabile, astfel că pentru un
p dat, entropia maximă este
Hmax(X) = – plogp – 2[(1 – p)/2]log[(1 – p)/2] =
= – plogp – (1 – p)log(1 – p) + 1 = 1 + H(p)
Prima parte a dublei inegalităti Shannon modificate devine în cazul critic
Hmax(X)
L – Hmax(X) = 1 – p – H(p) ≥ 0
Pentru valorile extreme, p = 0, p = 1, functia în p de mai sus devine 1,
respectiv 0 si inegalitatea este satisfăcută.
Derivata aceleiasi expresii este
– 1 – log[(1 – p)/p]
si este negativă pentru orice p. Functia de p este monotonă si scăzătoare de
la 1 la 0 si inegalitatea primă este satisfăcută pentru p oarecare.
Pentru inegalitatea a doua trebuie identificată tot asa situatia ce mai
defavorabilă. Aceasta se produce pentru α = (1 – p)/2. Entropia este în acest
caz
Hmin(X) = – plogp – (1 – p)log(1 – p) = H(p)
Se testează acum inegalitatea
L – H(X) ≤ L – Hmin(X) = 2 – p – H(p) < 1
La extreme, p = 0, p = 1, expresia în p ia valorile 2, respectiv 1. Nici una nu
satisface a doua parte a inegalitătii lui Shannon. Monotonia functiei în p nu
aduce cazuri noi. Codul nu poate fi de tipul Huffman pentru orice set de
probabilităti.
b. La fel poate fi tratat si acest punct al problemei. Există însă o cale mai
directă de tratare. Se observă că proprietatea de lungime medie minimă a
codului propus nu este îndeplinită. De pildă, pentru orice probabilitate a
ultimului dintre simboluri nenulă, codul {00, 01, 10, 11} este mai scurt în
medie fată de codul dat. Codul nu este compact si de aceea nu poate fi un
cod Huffman oricare ar fi probabilitătile simbolurilor.
c. Aici lungimea medie este Lc = 2. Dubla inegalitate a lui Shannon, 1 ≤ Lc < 2
nu este satisfăcută. Există totdeauna un cod de lungime medie mai mică
decât 2, de pildă codul {0, 1}. Codul propus nu este un cod Huffman pentru
toate probabilitătile posibile ale simbolurilor deoarece nu este compact.
61
Indicatie: Punctele a. si b. se rezolvă aplicând algoritmul Huffman pentru
coduri binare, binecunoscut. Punctul c. se rezolvă adaptând algoritmul la cazul
ternar: simbolurile din coada clasamentului probabilistic la fiecare etapă se
grupează câte trei, sursa redusă finală trebuie să aibă trei simboluri în caz
contrar se adaugă la sursa initială simboluri (fictive) de probabilitate nulă în
număr strict necesar (unul sau două).
Cuvinte ca Run!, Help! sau Fire! sunt scurte nu pentru că sunt utilizate frecvent,
ci, probabil, pentru că timpul este pretios în situatiile în care aceste cuvinte sunt
necesare. Se presupune că X = i cu probabilitatea pi, i = 1, 2, …, m. Fie li
numărul de simboluri binare în cuvântul de cod asociat cu X = i si fie ci costul
pe literă de cod în aceeasi situatie. Astfel, costul mediu C al descrierii lui X este
m
C= ∑
i= 1
pi cili .
1
i.i.d. – variabile aleatoare independente si identic distribuite.
62
Problema 54. Entropia relativă este costul codării inadecvate
Fie variabila aleatoare X care ia cinci valori posibile (1, 2, 3, 4, 5}. Se consideră
două distributii ale acestei variabile (v.tabelul).
Problema 56.
63
m
1
∑
i= 1 m
li = log 2 m
echivalentǎ succesiv cu
1 m m m
∑
m i= 1
li = log 2 m , ∑ li = m log 2 m , ∑i= 1 li
i= 1 2 = mm
.
Suma lungimilor cuvintelor de cod este totdeauna un numǎr întreg pozitiv.
Ultima egalitate impune ca m sǎ fie o putere întreagǎ si pozitivǎ a lui 2.
b. Se stie cǎ pentru orice distributie probabilisticǎ, lungimea medie a codului
optim si entropia sunt în relatia L < H + 1. Se defineste ca redundantǎ a unui
cod diferenta ρ = L – H. Pentru ce valori ale lui m, 2k ≤ m ≤ 2k+1, redundanta
codului optim este maximǎ? Care este valoarea limitǎ a acestei redundante
maxime, pentru m → ∞?
Solutie: Pentru valorile extreme, 2k si 2k+1, redundantele sunt nule. Pentru
valorile intermediare, cuvintele codului optim/compact au lugimile de k sau de
k + 1 biti. Nu pot fi toate de lungime k deoarece cuvintele ar fi prea putine,
codul n-ar mai fi unic decodabil. Pot fi toate de lungime k + 1 dar sunt prea
multe cuvinte. Dupǎ atribuire, sunt cuvinte ale codului diferite de unul din
cuvintele în surplus prin numai un bit. Cuvintele de cod care au pereche în
surplusul de cuvinte lungi de k + 1 biti si care diferǎ prin numai un bit de acelea
pot fi scurtate cu acel bit si incluse în cod. Codul rǎmâne unic decodabil dar
este si optimal (algoritmul Huffman poate confirma acest adevǎr). Dupǎ cum m
excede limita 2k cu 1, 2, …, 2k – 1 unitǎti, cuvintele de cod de lungime k + 1
sunt în numǎr de 2, 4, …, 2k+1 – 2, adicǎ 2(m – 2k), iar cuvintele de cod de
lungime k sunt în numǎr de m – 2, m – 4, …, m – 2k+1 + 2, adicǎ m – 2(m – 2k) =
2k+1 – m.
Lungimea medie a codului este
L=
m
(
1 k+1
(2 − m) k + 2(m − 2 k )(k + 1) )
ceea ce dupǎ prelucrare devine
2k + 1
L=
1
m
( )
m(k + 2) − 2k + 1 = (k + 2) −
m
Pentru 2k < m < 2k+1, redundanta codului este
2k + 1
ρ = L − H = ( k + 2) − − log 2 m
m
Functia
2k + 1
f ( x ) = ( k + 2) − − log 2 x
x
are un extrem (un maxim) în punctul de anulare a derivatei
2k + 1 1
f ′ ( x) = 2 −
x x ln 2
64
adicǎ pentru x = 2k+1ln2. În acest punct functia f(x) ia vloarea 1 – 1/ln2 –
lnln2/ln2 ≈ 0,0861. Pentru x → ∞ aceasta este si limita functiei în discutie.
Aceeasi este si limita cerutǎ de problemǎ deoarece un sir de valori m întregi, în
particular diferite cu mai putin de o unitate de un x real nu poate conduce la altǎ
limitǎ.
Problema 57.
Un cod nu este unic decodabil dacǎ si numai dacǎ existǎ o secventǎ finitǎ de
simboluri ale codului care poate fi interpretatǎ în moduri diferite în secventele
de cuvinte de cod.
În secvenţa
| A1 | A2 | A3 … Am |
- - - - - - - - - - - - - - - - - - - - - - - - - - - - -
| B1 | B2 | B3 … Bn |
unde fiecare Ai si Bi sunt cuvinte de cod, pot apǎrea situatii de acest gen. Se
observǎ cǎ B1 poate fi prefix pentru A1, rezultând si un oarecare sufix
reminiscent. Fiecare sufix reminiscent trebuie sǎ fie la rându-i un prefix sau un
cuvânt de cod, sau sǎ aibǎ un alt cuvânt ca prefix propriu, ceea ce produce un
alt sufix reminiscent. În final, ultimul sufix din secvenţǎ trebuie sǎ fie un cuvânt
de cod. Se poate pune la punct un test de unicǎ decodabilitate (testul Sardinas-
Patterson) în maniera care urmeazǎ:
• Se construieste o multime S care sǎ cuprindǎ toate sufixele reminiscente
posibile
• Codul este unic decodabil dacǎ si numai dacǎ mulţimea S nu contine cuvinte
de cod.
a. Se admite cǎ lungimile cuvintelor de cod sunt li, i = 1, 2, …, m. Gǎsiti o
limitare superioarǎ pentru numǎrul de elemente din S
b. Determinati care din codurile urmǎtoare sunt unic decodabile:
i. {0, 10, 11}
ii. {0, 01, 11}
iii. {0, 01, 10}
iv. {0, 01}
v. {00, 01, 10, 11}
vi. {110, 11, 10}
vii. {110, 11, 100, 00, 10}
c. Pentru fiecare din codurile unic decodabile de mai sus, construiti, dacǎ este
posibil, o secventǎ infinitǎ codatǎ cu un punct de început cunoscut, astfel
încât ea sǎ poatǎ fi interpretatǎ în douǎ moduri. Aceasta aratǎ cǎ dacǎ
cuvintele de cod finite sunt unic decodabile, cuvintele de cod infinite pot sǎ
nu fie unic decodabile.
d. Dovediti cǎ o asemenea secventǎ nu poate apǎrea într-un cod liber de prefix.
65
Problema 58. Codul Shannon
Se considerǎ procesul Markov cu trei stǎri U1, U2, … care are matricea de
tranzitie
U n− 1 \ U n S1 S 2 S3
S1 1/ 2 1/ 4 1/ 4
S2 1/ 4 1/ 2 1/ 4
S3 0 1/ 2 1/ 2
cu probabilitatea tranzitiei din starea S1 în starea S3 nulǎ. Proiectati trei coduri
C1, C2, C3 (unul pentru fiecare stare S1, S2, S3), fiecare cod aplicând elemente din
multimea {S1, S2, S3} pe secvente de valori binare 0 si 1, astfel încât acest
proces Markov sǎ poatǎ fi transmis cu compresie maximǎ prin schema
urmǎtoare:
a. Se observǎ simbolul prezent Si
b. Se selecteazǎ codul Ci
c. Se observǎ simbolul urmǎtor Sj si se trimite cuvântul de cod Cj care
corespunde lui Sj
d. Se repetǎ operatia pentru simbolul urmǎtor.
Care este lungimea medie a mesajului asociat simbolului urmǎtor conditionatǎ
de starea anterioarǎ S = Si utilizând aceastǎ schemǎ de codare?
Care este numǎrul mediu neconditionat de biti pe simbol al sursei?
Puneti în relatie aceastǎ lungime cu rata entropiei H(U) a lantului Markov.
66
CRIPTAREA
Lucrarea 7.
67
Sistemul RSA – de la intialele a trei cercetǎtori (Ron Rivest, Adi Shamir si Len
Adleman) care l-au inventat – este un mod inteligent de a realiza ideea de cheie
publicǎ. Iatǎ cum lucreazǎ aceasta:
• Generarea cheii. B stabileste douǎ numere prime mari, p si q. (“Mare”
înseamnǎ în zilele noastre câteva sute de digiti zecimali, curând poate va
însemna peste o mie). Pentru a gǎsi asemenea numere, B genereazǎ repetat
intregi din aceastǎ gamǎ si îi supune unui test datorat lui Fermat pânǎ când
douǎ din ele trec testul. Apoi B calculeazǎ n = p.q. De asemenea, B
genereazǎ la întâmplare un întreg e < n, cu singura restrictie de a fi prim cu
(p – 1) si cu (q – 1). Perechea (n, e) este de acum cheia publicǎ a lui B si o
face cunoscutǎ tuturor. Practic, pentru a face codarea mai usoarǎ, e este
adesea luat 3. Desigur, trebuie evitate numerele prime care sunt 1 mod 3.)
Acum B poate genera cheia lui secretǎ. Tot ce are de fǎcut este a calcula
(prin algoritmul lui Euclid) d = e– 1 mod (p – 1)(q – 1). Perechea (n, d) este
cheia privatǎ a lui B.
• Operarea. Ori de câte ori A sau oricine altcineva doreste sǎ-i trimitǎ un
mesaj lui B procedeazǎ astfel:
o Fragmenteazǎ mesajul în siruri de biti de lungime log n . (este
vorba aici de mai multe sute de biti). Se codeazǎ fiecare sir de biti
prin algoritmul care urmeazǎ.
o Fie x un astfel de sir de biti si se considerǎ ca fiind un întreg mod n.
A calculeazǎ xe mod n. Acesta aste mesajul codat e(x) pe care A îl
trimite lui B.
o La primirea lui e(x), B calculeazǎ e(x)d mod n. Putinǎ algebrǎ
( apelând la mica teoremǎ a lui Fermat pentru produsul a douǎ
numere prime) produce:
68
cum sǎ facǎ asta rapid. Sau, în sfârsit, E si-ar putea utiliza propria ei metodǎ
ingenioasǎ pentru a decoda e(x) fǎrǎ factorizarea lui n – este o convingere largǎ
cǎ nu existǎ o asemenea metodǎ.
Astfel, dupǎ toate dovezile existente, RSA este sigur pentru un n potrivit de
mare.
Programul alǎturat este o ilustrare a modului cum lucreazǎ sistemul de criptare
RSA. Operatiile de criptare si de decriptare sunt puse laolaltǎ, în sucesiunea
fireascǎ. Nu s-a recurs la numere prime p, q foarte mari pentru a nu depǎsi
posibilitǎtile aritmetice curente curente ale pachetului Matlab. Studentii sunt
îndemnati sǎ înlocuiascǎ numerele prime p, q propuse cu altele. Sistemul de
criptare/decriptare va functiona atât timp cât numerele alese îndeplinesc
conditiile precizate mai sus. Se recomandǎ si încercarea si a unor numere p, q
compuse. Se va putea observa în acest caz functionarea defectuoasǎ sau
nefunctionarea sistemului.
clear
p=7;q=13; % se aleg doua numere prime p, q (mari)
n=p*q;
e=5; % cheia publica: (e, n)
cheia_publica=[e n]
d=29; % cheia privata: (d, n)
m=floor(n*rand); % mesajul de criptat (generat aleator)
mesajul_de_criptat=m
b=1;
for i=1:e
b=m*b;
a=floor(b/n);
b=b-a*n;
end % operatia de criptare
m=b; % mesajul criptat
mesajul_criptat=b
cheia_privata=[d n]
b=1;
for i=1:d
b=m*b;
a=floor(b/n);
b=b-a*n;
end % operatia de decriptare
mesajul_decriptat=b % mesajul decriptat
Curbe eliptice peste Zp: Fiind dat un număr prim p, o curbă eliptică peste Zp
este o congruenţă y2 = x3 + ax + b mod p la care se adaugă un punct O la infinit
astfel încât conditia de “nesingularitate” 4a3 + 27b2 ≠ 0 mod p să fie satisfăcută.
Fiind date punctele P1 = (x1, y1) si P2 = (x2, y2) pe curba eliptică se defineste
P1 + P2 = (λ2 – x1 – x2, λ(x1 – x3) – y1)
cu
69
y2 − y1
x − x pentru P1 ≠ P2
λ = 2 2 1
3 x1 + a pentru P1 = P2
2 y1
Se consideră totodată că (x1, y1) + (x1, –y1) = O si P1 + O = O + P1 = P1. Acesta
este un grup abelian denumit Ep(a, b).
Exemplu: Se consideră curba eliptică y2 = x3 + x + 6 peste Z11*. Pentru a
determina punctele din E, se ia fiecare punct din Z11, se calculează x3 + x + 6 si
apoi se rezolvă ecuatia y2 ≡ x3 + x + 6 mod 11.
Calculul acesta cere evaluarea de radicali modulo 11. Există o formulă explicită
pentru aceasta deoarece 11 ≡ 3 mod 4. De fapt, rădăcinile pătrate ale unui rest
pătratic r sunt ±r(11 + 1)/4 ≡ r3 mod 11. Prin calcul si pentru calcule ulterioare se
completează tabelul următor:
x x3 + x + 6 ∈ QR11? y
0 6 nu
1 8 nu
2 5 da 4, 7
3 3 da 5, 6
4 8 nu
5 4 da 2, 9
6 8 nu
7 4 da 2, 9
8 9 da 3, 8
9 7 nu
10 4 da 2, 9
Curba eliptică are pe ea 13 puncte (x, y), incluzând si punctul de la infinit. Fiind
de ordinul 13 (prim) ea însăsi trebuie să fie un grup ciclic. De pildă, dacă se ia
generatorul α = (2, 7).
Puterile lui α, de pildă (2, 7) + (2, 7), pot fi calculate după cum urmează. Se
evaluează mai întâi λ:
λ = (3∙22 + 1)(2∙7)–1 mod 11 = (2∙3)–1 mod 11 = 2∙4 mod 11 = 8
Asadar x3 = 82 – 2 – 2 = 5 mod 11 si y3 = 8(2 – 5) – 7 = 2 mod 11. Decurge de
aici că (2, 7) + (2, 7) = (5, 2).
Apoi, (2, 7) + (2, 7) + (2, 7) = 2(2, 7) + (2, 7) = (5, 2) + (2, 7).
Sisteme de criptare cu curbe eliptice: Algoritmul foarte general ElGamal se
poate aplica la subgrupul ciclic Z n1 al lui Ep(a, b), dar factorul lui de dezvoltare
este 4 (fată de 2 pentru Zp). În plus, spatiul textelor în clar (plaintext space)
constă din punctele din Ep(a, b) si nu există metodă convenabilă de a genera în
mod determinist puncte din Ep(a, b).
70
Se ia o curbă eliptică Ep care contine un subgrup ciclic H = Z n1 cu algoritm
discret intractabil. Spatiul textelor în clar este Z p × Z p si spatiul textelor cifrate
* *
(ciphertext) este E p × Z p × Z p .
* *
clear
prime=primes(100); % generare de numere prime
[m,n]=size(prime);
m=unidrnd(n,1,1);
p=prime(m)
p=11
a=1;b=6;
if mod(4*a^3+27*b^2,p)==0
mesaj='Nu merge!'
break
end
x=1:(p-1);
x2=mod(x.^2,p);
y2=mod(x.^3+a*x+b,p);
k=0;
for i=1:(p-1)
for j=1:(p-1)
if y2(i)==x2(j)
k=k+1;
per(k,1:2)=[i j]; % calculul punctelor de pe curba
eliptica
end
end
end
[m,n]=size(per)
n=unidrnd(m,1,1);
n=6
alfa=per(n,:) % alegere dintre punctele de pe curba eliptica
alfa=[2 7]
for i=1:(p-1)
for j=1:(p-1)
if mod(x(i)*x(j),p)==1
invx(i)=x(j);
71
end
end
end
exs=unidrnd(m-1,1,1) % alegere exponent secret
exs=7
la=mod(2*alfa(2),p)
la=invx(la)
la=mod((3*alfa(1)^2+exs)*la,p)
beta=[0 0];
for i=1:la
beta(1)=mod(la^2-alfa(1)-beta(1),p);
beta(2)=mod(la*(alfa(1)-beta(1))-alfa(2),p);
end
beta
Se presupune cǎ din eroare sau deliberat cineva alege o valoare pentru n care nu
este un produs de douǎ numere prime, adicǎ n = pq cu p > 1, q > 1 si q este
compus. Ar fi, evident, mai usor de factorizat ceea ce ar pune o problemǎ de
risc sub aspectul securitǎtii. Dar vor functiona operatiile de criptare si de
decriptare cu acest n? Sustineti rǎspunsul.
Solutie: Nu, criptarea/decriptarea nu mai functioneazǎ. Pentru a avea un
contraexemplu, fie n = 45 = 5.9. Dacǎ punem p = 5 si q = 9, atunci pentru o
cheie de criptare (e, 45), am alege o cheie de decriptare (d, 45) pentru care de ≡
1 mod ((5 – 1)(9 – 1)), adicǎ
de ≡ 1 (mod 32)
Astfel, dacǎ e = 5, inversul mod 32 este d = 13. Dar dacǎ criptǎm si decriptǎm
mesajul M = 2, obtinem
(25)13 = 265 ≡ 32 (mod 45).
Mai general, RSA se bazeazǎ pe faptul cǎ (Me)d ≡ 1 (mod n), deoarece aceastǎ
relatie este cea care asigurǎ cǎ decriptarea este inversa criptǎrii. Relatia se va
mentine dacǎ de ≡ 1 (mod ϕ(n)). Dar, dacǎ q este compus, ϕ(n) ≠ (p – 1)(q – 1)
si astfel vom avea propozitia de ≡ 1 mod ((p – 1)(q – 1)) falsǎ. În consecintǎ, în
cazul exemplificat criptarea RSA nu poate lucra.
Fie p si q numere prime si N = pq. Arǎtati cum se pot determina p si q fiind date
N si (p – 1)(q – 1). Cu alte cuvinte, fiind datǎ cheia publicǎ (e, N), e exponentul
de criptare si N modulul RSA, precum si valoarea ϕ(N) = (p – 1)(q – 1), este
posibil a calcula p si q prin operatii algebrice simple (în timp polinomial).
Aceasta aratǎ cǎ determinarea lui ϕ(N) este la fel de grea ca si factorizarea.
Solutie: Fiind date pq = N si (p – 1)(q – 1) = ϕ(N), urmeazǎ a afla numerele p si
q. Se poate pune q = N/p dupǎ care o înlocuire în ecuatia a doua produce dupǎ
câteva prelucrǎri algebrice ecuatia în p
p2 + (ϕ(N) – N – 1)p + N = 0
72
care poate fi rezolvatǎ aplicând formula cunoscutǎ. Dacǎ p a fost gǎsit, este usor
a-l gǎsi si pe q.
73
74
CODAREA PENTRU CANALE CU PERTURBATII
Lucrarea 8
75
clear
m=4;
n=2^m-1;
s=strcat('Codul Hamming (',int2str(n),',',int2str(n-m),')');
disp(' ')
disp(s)
for i=1:n
a=dec2binvec(i,m);
h1(:,i)=a';
end % generarea matricii de control
h=h1;
matricea_de_control=h
z=sum(h);
j=0;k=0;
for i=1:n
if z(i)>1
j=j+1;
h(:,j)=h1(:,i);
else
k=k+1;
h(:,n-m+k)=h1(:,i);
end
end % ordonarea matricii de control
matricea_de_control_ordonata=h % se afiseaza matricea de
control ordonata
g=[eye(n-m) (h(:,1:(n-m)))']; % construirea matricei
generatoare
matricea_generatoare=g'
for i=1:n
z(i)=binvec2dec(h(:,i)');
end
inf=unidrnd(2,1,n-m)-1; % se genereaza n-m biti
informaationali
biti_de_informatie=inf % se afiseaza bitii informationali
for j=1:m
p(j)=0;
for i=1:n-m
p(j)=bitxor(p(j),bitand(h(j,i),inf(i)));
end
end % se calculeaza cei m biti de protectie
cod=[inf p]; % se genereaza cuvantul de cod
cuvantul_de_cod=cod
b=h*cod';
b=b-2*(floor(b/2));
vectorul_sindrom=b % se afiseaza sindromul
l=unidrnd(n); % se introduce eroare pe bitul l
s=strcat('Se inverseaza bitul de pe pozitia');
disp(s)
disp(int2str(l))
cod(l)=bitxor(1,cod(l));
cuvantul_cu_eroare=cod
b=h*cod';
b=b-2*(floor(b/2));
vectorul_sindrom=b % se afiseaza sindromul
76
Tema 2: Un cod Hamming (7,4) în acţiune
77
disp(' ')
s=strcat('Numar de caractere:',num2str(nc));
disp(s)
biti=zeros(1,14*nc);
for i=1:nc
vec=dec2binvec(aski(i),8);
prov=zeros(n-m:n);
for i1=1:n
prov(:,i1)=and(vec(1:4),(g(:,i1))');
end
pro=zeros(1,n);
for i1=1:n
for j=1:(n-m)
pro(i1)=xor(pro(i1),prov(j,i1));
end
end
biti(14*(i-1)+1:14*i-7)=pro;
prov=zeros(n-m:n);
for i1=1:n
prov(:,i1)=and(vec(5:8),(g(:,i1))');
end
pro=zeros(1,n);
for i1=1:n
for j=1:(n-m)
pro(i1)=xor(pro(i1),prov(j,i1));
end
end
biti(14*(i-1)+8:14*i)=pro;
end % se compun cuvintele de cod Hamming
k1=unidrnd(61); % se alege aleator cuvantul de cod purtator
de eroare
k2=unidrnd(7); % se alege aleator pozitia bitului eronat
s=strcat('Se introduce o eroare în cuvantul de
cod:',num2str(k1),' bitul:',num2str(k2));
disp(' ')
disp(s)
biti(14*(k1-1)+k2)=xor(1,biti(14*(k1-1)+k2)); % se inverseaza
un bit
b=zeros(1,nc);
for i=1:nc
a1=[biti(14*(i-1)+1:14*i-7-3) biti(14*(i-1)+8:14*i-3)];
b(i)=binvec2dec(a1);
end
disp(' ')
disp('Textul cu eroarea (eventual observabila):')
disp(' ')
disp(char(b))
for i=1:2*nc
cuv=(biti(7*(i-1)+1:7*i));
si=zeros(3,1);
for k=1:m
pro=and(h(k,:),cuv);
si(k)=mod(sum(pro),2);
end
78
if sum(si)~=0
for j=1:n
prov=xor(si,h(:,j));
if sum(prov)==0
k1=j;
end
end
biti(7*(i-1)+k1)=xor(1,biti(7*(i-1)+k1)); %
corectare!
end
end % se localizeaza eroarea si se corecteaza
b=zeros(1,nc);
for i=1:nc
a1=[biti(14*(i-1)+1:14*i-7-3) biti(14*(i-1)+8:14*i-3)];
b(i)=binvec2dec(a1);
end
disp(' ')
disp('Textul cu eroarea corectata:')
disp(' ')
disp(char(b))
disp(' ')
Codarea prin metoda run-length este una din cele mai simple sau poate cea mai
simplǎ metodǎ de codare în scopul comprimǎrii fǎrǎ pierdere de informatie a
unui fisier care contine o secventǎ de întregi.
a. Scrieti o procedurǎ simplǎ (în pseudocod) care primeste o secventǎ de
numere naturale a1, …, an si returneazǎ o secventǎ codatǎ de întregi b1, …,
bn. Ideea de bazǎ este a genera secventa codatǎ astfel ca o subsecventǎ din
secventa initialǎ de 3 sau mai multe numere consecutive identice cu o
subsecventǎ de numai douǎ: primul care indicǎ lungimea secventei, al
doilea care este însusi numǎrul repetat. De pildǎ, secventa 6, 2, 3, 4, 4, 4, 5,
6, 7, 7, 7, 7, 8 este codatǎ ca 6, 2, 3, -3, 4, 5, 6, -4, 7, 8. Dupǎ cum se
observǎ, secventa codatǎ este mai scurtǎ decât cea initialǎ.
b. De ce este necesar semnul minus?
c. Scrieti o procedurǎ de decodare care primeste secventa codatǎ si restituie
secventa de dinainte de codare
d. Descrieti tipul de secvente la intrare care produce cel mai rǎu caz de
complexitate temporalǎ pentru combinatia de algoritmi de codare si de
decodare (numǎrati numai operatiile de comparare)
e. Produceti o formulǎ pentru fiecare algoritm, care sǎ exprime numǎrul de
comparatii necesare ca functie de lungimea secventei de intrare n în cazul
cel mai rǎu
f. Utilizati notatia “big-O” pentru a descrie cazul cel mai rǎu pentru algoritmii
utilizati.
Problema 64
79
Informatia generatǎ de o sursǎ se poate reprezenta prin numere binare de
lungime egalǎ cu 7 biti. Se adaugǎ un bit suplimentar, un bit de paritate, prin
care se obtine un cod de paritate constantǎ care include si cuvântul de cod nul.
a. Arǎtati cǎ ponderea Hamming a acestui cod este 2.
b. Arǎtati cǎ acest cod este un cod liniar.
Problema 65
Detinând cunostinte exclusiv despre codul Hamming (7, 4), Marcel J.E.Golay a
generalizat ideea lui Hamming la coduri perfecte corectoare de o eroare cu baza
orice număr prim. După ce a terminat acest aspect, Golay a îneput să caute
coduri perfecte corectoare de mai multe erori. Unul din codurile Golay este de
interes special deorece a fost utilizat mai târziu pentru a genera pachete în
spatiul 24-dimensional.
Se reaminteste că un cod corector de x erori trebuie să fie caracterizat de o
distantă Hamming minimă de cel putin 2x + 1. Pentru ca un cod să fie perfect,
numărul de vârfuri ale unui n-cub unitar dintr-o sferă de rază x care-l cuprinde
trebuie să fie o putere a lui r, unde r este rădăcina codului. În cazul binar
x
∑
i= 0
Cni = 2 k
∑
i= 0
C90i = 212 si ∑
i= 0
i
C23 = 211
În cazul n = 90 Golay a arătat că nu există nici un cod perfect (90, 78) corector
a două erori. Pentru n = 23 Golay a găsit un cod (23, 12) corector de 3 erori si a
si dat o matrice pentru el
80
1 0 0 1 1 1 0 0 0 1 1 1
1 0 1 0 1 1 0 1 1 0 0 1
1 0 1 1 0 1 1 0 1 0 1 0
1 0 1 1 1 0 1 1 0 1 0 0
1 1 0 0 1 1 1 0 1 1 0 0
A = 1 1 0 1 0 1 1 1 0 0 0 1
1 1 0 1 1 0 0 1 1 0 1 0
1 1 1 0 0 1 0 1 0 1 1 0
1 1 1 0 1 0 1 0 0 0 1 1
1 1 1 1 0 0 0 0 1 1 0 1
0 1 1 1 1 1 1 1 1 1 1 1
Prin atasarea la aceasta a matricii unitate I11, se obtine o matrice de verificare de
aceeasi formă cu acelea pentru codurile corectoare de o eroare.
Pentru a construi codul, din digitii mesajului y1, …, yr se evaluează digitii de
control (de paritate) x1, …, xk astfel încât
12
xi + ∑
j= 1
aij y j ≡ 0 mod 2 , i = 1, 2, …, 11
Problema 68.
81
a. Eliminati prima restricitie, ecuatia (1) si definiti un nou cod H8* alcătuit din
secvente de 8 valori binare care satisfac (doar) restrictiile (2), (3), (4). Care
este dimensiunea si care este rata acestui nou cod? Este (si) H8* capabil a
corecta 1 eroare? Explicati matematic.
b. Eliminati acum restrictia (1) si stergeti bitul x7 pentru a obtine un cod nou
H7 alcătuit din secvente mai scurte, de 7 biti (operatia se numeste perforarea
codului H8). Care sunt dimensiunea si rata noului cod? Este (încă) acest cod
capabil a corecta 1 eroare? Explicati matematic.
Problema 69.
Problema 70.
Problema 71.
82
1 1 0 0 1 0
B = 0 1 1 0 1 1
1 1 1 1 0 0
1 0 1 1 0 1
C = 0 1 1 0 1 1
1 0 0 1 1 0
Este vreuna dintre aceste matrici generatoare a unui cod liniar binar (6, 3)?
Sunt printre ele matrici care generează acelasi cod?
Solutie: Matricea A este în forma canonică. Pentru a aduce pe B în forma
canonică se procedează pas cu pas la: adunarea liniei prime la a treia, adunarea
liniei a doua la prima si, în final, adunarea liniei a treia la prima si la a doua
(eliminarea Gauss):
1 1 0 0 1 0 1 0 1 0 0 1 1 0 0 1 1 1
B ~ 0 1 1 0 1 1 ~ 0 1 1 0 1 1 ~ 0 1 0 1 0 1
0 0 1 1 1 0 0 0 1 1 1 0 0 0 1 1 1 0
Matricea aceasta coincide cu A.
Pentru a aduce pe C la forma canonică se aplică tot eliminarea Gauss: se adună
prima linie la a treia, apoi se adună linia a treia la prima si la a doua:
1 0 1 1 0 1 1 0 0 1 0 0
C ~ 0 1 1 0 1 1 ~ 0 1 0 0 0 0
0 0 1 0 1 1 0 0 1 0 1 1
Forma canonică a matricei C este diferită si de A si de B în forma lor canonică.
Toate cele trei matrici au rangul 3, asadar toate generează coduri (6, 3). A si B
genereză acelasi cod, C generează un cod diferit.
Problema 72.
Problema 73.
Problema 74.
83
Se consideră C un cod binar [6, 3] cu matricea generatoare
1 1 0 0 1 0
G = 0 1 1 0 1 1
1 1 1 1 0 0
Regula de codare c = (a1, a2, a3)G nu este sistematică. Stabiliti un operator
matricial J care să aplice cuvintele de cod (printr-un decodor) pe bitii de
informatie corespunzători (pentru utilizatorul ultim), adică
(a1, a2, a3) = c J
Problema 75.
Fie un cod C care admite următorul decodor optimal (de distantă minimă)
Problema 76.
84
standard2 pentru C, dată imediat mai jos, pentru a răspunde la întrebările
privitoare la performantele decodării.
Matricea standard
0000000 1000111 0101011 0011101 1101100 1011010 0110110 1110001
0000001 1000110 0101010 0011100 1101101 1011011 0110111 1110000
0000010 1000101 0101001 0011111 1101110 1011000 0110100 1110011
0000100 1000011 0101111 0011001 1101000 1011110 0110010 1110101
0001000 1001111 0100011 0010101 1100100 1010010 0111110 1111001
0010000 1010111 0111011 0001101 1111100 1001010 0100110 1100001
0100000 1100111 0001011 0111101 1001100 1111010 0010110 1010001
1000000 0000111 1101011 1011101 0101100 0011010 1110110 0110001
0000011 1000100 0101000 0011110 1101111 1011001 0110101 1110010
0000110 1000001 0101101 0011011 1101010 1011100 0110000 1110111
0001100 1001011 0100111 0010001 1100000 1010110 0111010 1111101
0011000 1011111 0110011 0000101 1101100 1000010 0101110 1101001
0001010 1001101 0100001 0010111 1100110 1010000 0111100 1111011
0010100 1010011 0111111 0001001 1111000 1001110 0100010 1100101
0010010 1010101 0111001 0001111 1111110 1001000 0100100 1100011
0111000 1111111 0010011 0100101 1010100 1100010 0001110 1001001
Problema 77.
Examinarea matricei standard din problema precedentă arată că s-au făcut unele
alegeri arbitrare pentru cuvintele lider de comultimi/codomenii (cosets)
(pattern-uri de eroare “corectabilă”) în linia 9 si următoarele. (Posibilitătile
diferite corespund diferentelor în ordonarea elementelor slab-ponderate din lista
de bază (scratch) de la care pornind s-a construit matricea standard.)
a. În linia ultimă, se presupune că 1001001 a fost ales în locul lui 0111000 ca
lider corect. Care va fi ultima linie a noii matrici standard? Calculati P(E)
pentru noul decodor cu noua matrice standard.
2
Matricea standard. În teoria codării, matricea standard (sau matricea slepian) este o matrice
cu dimensiunile qn−k×qk care listează toate elementele unui spatiu vectorial particular Fqn.
Matricea standard se utilizează pentru a decoda codurile liniare, adică pentru stabilirea
cuvântului de cod corespunzător unui vector-mesaj primit. În cazul de fată, dar si în general,
matricea standard are în prima linie cuvintele codului, în prima coloană vectorii eroare lideri de
comultimi/codomenii care se regăsesc pe aceeasi linie. Celelalte elemente se obtin prin
însumarea bit-cu-bit modulo 2 a vectorilor eroare cu cuvintele de cod, pe linia, pe coloana
corespunzătoare.
85
b. Repetati punctul a. dar cu utilizarea lui 1111111 în loc de 0111000 ca lider
de comultime/codomeniu. (De observat că această alegere nu conduce la o
matrice standard! De ce?)
Problema 78.
Problema 79.
Problema 80.
86
Problema 81.
Problema 82.
Problema 83.
Pentru a genera un cod perfect Golay G23 se pot utiliza două polinoame
generatoare, g1(x) = x11 + x10 + x6 + x5 + x4 + x2 + 1 si g2(x) = x11 + x9 + x7 + x6 +
x5 + x + 1.
a. Arătati că g1(x) si g2(x) sunt polinoame inverse unul altuia.
b. În ce relatie sunt cele două versiuni de G23? Sunt codurile generate de g1(x)
si g2(x) identice? Sunt echivalente? De ce?
Problema 84.
87
Problema 85.
Problema 86.
Problema 87.
d.
γ = ∏ β
.
β ∈ GF ( 2 4 ) − {0}
Problema 88.
88