UNIVERSITEIT GENT. Informatietheorie. H. Steendam. 1 februari Universiteit Gent Vakgroep Telecommunicatie en Informatieverwerking (TELIN)

UNIVERSITEIT

GENT

Informatietheorie Prof. dr. ir . H. Steendam

1 februari 2010

Universiteit Gent Vakgroep Telecommunicatie en Informatieverwerking (TELIN) St. Pietersnieuwstraat 41 9000 Gent

Inhoudsopgave 1

2

3

Inleiding

5

1.1 Informatietheorie 1.2 Digitale communicatie

5 9

Definitie van informatiemaat

13

2.1 2.2 2.3 2.4

13 15 22 25

Mutuele informatie en eigeninformatie Gemiddelde mutuele informatie en entropie Eigenschappen van entropie en mutuele informatie Informatiemaat voor continue toevalsgrootheden

Broncodering

28

3.1 Inleiding 3.2 Bronmodellen 3.2.1 Discrete geheugenloze bronnen 3.2.2 Discrete bronnen met geheugen 3.2.3 Analoge bronnen 3.3 Codering van discrete bronnen 3.4 Codering voor discrete geheugenloze bronnen 3.4.1 Vas te-lengte codes 3.4.2 Variabele-lengte codes 3.4.3 Vectorcodering 3.5 Codering voor discrete stationaire bronnen 3.6 Het Lempel-Ziv algoritme 3.6.1 Het LZ77 algoritme 3.6.2 Het LZ78 algoritme

28 28 29 30 30 30 31 31 36 42 44 47 48 52

3.6.3 Het LZW algoritme 3.7 Quantisatie van analoge bronnen 3.7.1 Optimale quantisatie 3.7.2 Scalaire quantisatie 3.7.3 Vectorquantisatie 4 Kanaalcodering

4.1 Inleiding 4.2 Kanaalmodellen 4.2.1 Discreet geheugenloos k an aal 4.2.2 Kana al met discrete ingang en continue uitgang 4.2.3 Golfvormkanaal 4.3 Capaciteit v an een kanaal 4.3.1 Discreet geheugenloos kanaal 4.3.2 Kanaal met discrete ingang en continue uitgang 4.3.3 Golfvormkanaal 4.4 Kanaalcoderingstheorema 4.4.1 Ongelijkheid van Fano 4.4.2 Omgekeerde van het kanaalcoderingstheorema 4.4.3 Kanaalcoderingstheorema 4.4.4 Samenvatting 5

Performantie van binaire lineaire blokcodes

5.1

Lineaire blokcodes 5.1.1 Definitie 5.1.2 Bijzondere blokcodes 5.2 Performantie van codes 5.2.1 Performantie van harde decoders 5.2.2 Performantie van zachte decoders 5.2.3 Vergelijking van de performantie van harde en zachte decoders 5.3 Grenzen voor de minimale afst an d van codes 5.3.1 Hamminggrens 5.3.2 Singletongrens

53 57 57 61 67 74

74 75 75 77 78 80 80 83 87 90 90 95 97 98 103

103 103 106 113 113 119 . . 125 126 127 128

5.3.3 5.3.4 5.3.5

Plotkingrens Eliasgrens Varsharmov-Gilbertgrens

6 Niet-binaire polynomiale codes

6.1 Definitie 6.2 Eindige velden (Galois velden) 6.3 Constructie van polynomiale codes 6.4 Generatie van polynomiale codes 6.5 Generatormatrix en checkmatrix 6.6 Het syndroom 6.7 Algebraïsche decodeertechnieken 6.8 Transformaties in eindige velden 6.9 Decoderen van BCH codes 6.10 Oplossen van de sleutelvergelijking 6.11 Performantie 6.12 Concatenatie van codes 7 Convolutionele codes

7.1 Inleiding 7.2 Encodering van convolutionele codes 7.2.1 Schuifregister en generatorsequenties 7.2.2 Generatormatrix 7.2.3 Veeltermnotatie 7.3 Grafische voorstelling van convolutionele codes 7.4 Eigenschappen van convolutionele codes 7.4.1 Afstandseigenschappen van convolutionele codes 7.4.2 Catastrofale codes 7.4.3 Grenzen op de vrije afstand van convolutionele codes 7.5 Decoderen van convolutionele codes - het Viterbi algoritme 7.6 Grenzen op de performantie van convolutionele codes 7.6.1 Zachte decodering 7.6.2

Harde decodering

129 129 129 131

131 131 139 141 144 146 151 154 158 160 166 167 172

172 172 172 175 177 178 187 187 190 192 192 200 200 204

7.6.3 Vergelijking tussen harde en zachte decodering

206 206

7.7 Puncturing

4

Hoofdstuk 1 Inleiding 1.1 Informatietheorie Informatietheorie werd ontwikkeld in de tweede helft van de twintigste eeuw om een antwoord te zoeken op een aantal fundamentele vragen. In het dagelijkse leven komen we immers in contact met verschillende factoren waarvan we de uitkomst a priori niet kennen, dus die beschreven kunnen worden als een toevalsproces. Een aantal voorbeelden van toevalsprcnuihdgejkslvzntrigadelo,hvrk(elotuign gebruiken een bepaalde weg in een bepaald tijdsinterval, belangrijk voor het voorspellen van files), het weer, de economie (in welke aandelen moet men investeren), opslag van data, audio en video, telefonie, ... De mens houdt niet van onzekerheid, en wenst voorspellingen te kunnen maken over de onzekerheden in het leven. De informatietheorie kan worden gebruikt om de uitkomst van deze toevalsprocessen tot op een zekere hoogte te kunnen voorspellen. In de informatietheorie worden een aantal grootheden gedefinieerd, zoals de entropie en de mutuele informatie. Zo is de entropie van een toevalsproces gelijk aan de minimale complexiteit waarmee een toevalsproces k an worden beschreven. De mutuele informatie is een maat voor het datadebiet dat men kan versturen over een kanaal. Daarnaast is de mutuele informatie ook gelijk a an de toename in de verdubbelingssnelheid van de rijkdom bij gegeven neveninformatie wanneer men speculeert op de beurs. Informatietheorie antwoordt op twee fundamentele vragen in de communicatietheorie: "Wat is de limiet voor datacompressie?" (antwoord = de entropie van de bron) en "Wat is de limiet voor datatransmissie over een kanaal?" (antwoord = de capaciteit van het kan aal). Om deze reden wordt informatietheorie veelal beschouwd als een onderdeel van de communicatietheorie. Echter, informatietheorie is veel meer dan enkel een onderdeel van de communicatietheorie. Informatietheorie levert ook een fundamentele bijdrage tot de statistische fysica (thermodynamica), computerwetenschappen (Kolmogorov-complexiteit of algoritmische complexiteit), logische conclusies in de statistiek (Occam's Razor: "De eenvoudigste verklaring is de beste") en tot de probabiliteitsleer en de statistiek (foutwaarschijnlijkheid bij optimale hypothesetesten en estimatie).

Figuur 1.1: Verband informatietheorie met andere domeinen In figuur 1.1 wordt het verband getoond van de informatietheorie met andere domeinen. Zoals in de figuur te zien is, overlapt de informatietheorie met andere domeinen, zoals de fysica (thermodynamica), de wiskunde (probabiliteitsleer), communicatietheorie en computerwetenschappen (Kolmogorov-complexiteit). We beschrijven nu iets meer gedetailleerd de verschillende domeinen in de figuur. Communicatietheorie

In het begin van de jaren 1940 dacht men dat, w an neer men informatie wenst te versturen aan een hoger debiet, de kans op een fout toeneemt. Sh an non bewees dat dit niet het 6

geval was zolang het debiet a an informatie lager is dan de capaciteit van het kanaal. De capaciteit van een kanaal kan men op een eenvoudige m anier berekenen aan de hand v an an het kanaal. Shannon bewees verder dat toevalsprocessen zoals deruiskat nv muziek en spraak een absolute complexiteit hebben waaronder men het signaal niet verder kan comprimeren. Deze ondergrens noemde hij de entropie v an het systeem, naar analogie met de entropie bij thermodynamica, en argumenteerde dat indien de entropie van een bron kleiner is dan de capaciteit van het kanaal waarover men de informatie wenst te versturen, op een asymptotische wijze foutvrije communicatie kan bekomen worden. In een praktisch digitaal communicatiesysteem is het debiet aan informatie dat men wenst te versturen dus naar onder begrensd door de entropie van de bron en naar boven begrensd door de capaciteit van het kanaal. Alle bestaande praktische modulatieschema's en datacompressieschema's liggen tussen deze twee limieten. Informatietheorie geeft ook aan hoe men deze limieten in de digitale communicatie kan bereiken. Echter, deze theoretische optimale communicatieschema's zijn in de praktijk meestal zeer onpraktisch en veel te complex. Het is vooral te d anken aan de vooruitgang in het domein van de geïntegreerde circuits en het ontwerp van goede codes dat de bovengrens voor het debiet - de capaciteit van het kanaal - en de ondergrens voor datacompressie de entropie van de bron - binnen bereik beginnen te komen. Een goed voorbeeld van de toepassing van informatietheorie is het compact disk digital audio systeem. Computerwetenschappen (Kolmogorov-complexiteit) Kolmogorov, Chaitin en Solomonoff verkondigden het idee dat de complexiteit van een datasequentie kan gedefinieerd worden aan de hand van het kortste binaire programma dat nodig is om de datasequentie te genereren. De complexiteit wordt dus beschouwd als de minimale beschrijvingslengte. Deze definitie van de complexiteit is een universele grootheid, m.a.w. ze is onafhankelijk van de beschouwde computer, en is dus v an fundamenteel belang. De Kolmogorov-complexiteit vormt de basis van de theorie van beschrijvende complexiteit. De Kolmogorov-complexiteit K is nagenoeg gelijk aan de entropie H van Shannon, indien de datasequentie afkomstig is van een bron met entropie H. De theorie van Kolmogorov en Shannon zijn dus equivalent. De Kolmogorov-complexiteit wordt in de computerwetenschappen als meer fundamenteel beschouwd als de entropie van Shannon, aangezien het de ultieme datacompressie a angeeft en leidt tot een consistente procedure om logische conclusies te trekken. Er bestaat een bijkomend verband tussen de algoritmische complexiteit en de rekencomplexiteit van een datasequentie. Men k an de rekencomplexiteit (complexiteit in de tijd) en de Kolmogorov-complexiteit (de lengte van het programma of de beschrijvende complexiteit) beschouwen als respectievelijk de uitvoeringstijd van het programma en de lengte van het programma. De Kolmogorov complexiteit concentreert zich op de minimalisatie van de lengte, terwijl de rekencomplexiteit zich concentreert op de minimalisatie van de uitvoeringstijd. Tot nu toe is er echter weinig onderzoek gedaan op het gezamenlijk minimaliseren van zowel de lengte als de uitvoeringstijd.

Fysica (Thermodynamica)

Statistische mechanica is de oorsprong van de term entropie en de tweede wet van de thermodynamica. De tweede wet van de thermodynamica zegt dat de entropie steeds toeneemt. De tweede wet van de thermodynamica verwerpt onder an dere het bestaan van perpetuum mobile machines. Wiskunde (Probabiliteitsleer en statistiek)

De fundamentele grootheden van de informatietheorie - entropie en mutuele informatie zijn gedefinieerd als functies van distributies v an toevalsgrootheden. Daarnaast beschrijven zij het gedrag van lange sequenties van toevalsgrootheden en laten ons toe de probabiliteit van zeldzame gebeurtenissen te schatten (theorie v an grote afwijkingen) en de beste error exponent voor hypothesetesten te bepalen. Filosofie van de wetenschap (Occam's Razor)

William van Occam verkondigde dat "Causes shall not be multiplied beyond necessity", of met andere woorden gezegd "De eenvoudigste verklaring is de beste". Solomonoff en Chaitin argumenteerden dat men een universele goede predictieprocedure bekomt wanneer men een gewogen combinatie neemt van alle programma's die de data verklaren en observeren wat de volgende uitgang is. Deze procedure werkt voor vele problemen die de statistiek niet k an beschrijven. Bijvoorbeeld, met deze procedure is men in staat de decimalen van 7r te produceren. Wanneer deze procedure wordt toegepast op de effectenbeurs kan men alle 'wetten' v an de beurs vinden en deze op een optimale wijze extrapoleren. In principe is deze procedure zelfs in staat de fysicawetten van Newton te vinden. Het is duidelijk dat deze procedure in vele gevallen zeer onpraktisch is, aangezien de eliminatie van alle computerprogramma's die er niet in slagen de data correct te genereren veel tijd in beslag zou nemen. In theorie is men met deze procedure zelfs in staat de toekomst te voorspellen. Economie (Investeringen)

Herhaald investeren op een stationaire beurs resulteert in een exponentiële groei van de rijkdom. De snelheid waarmee de rijkdom groeit (ook de verdubbelingssnelheid genoemd) is het duale van de entropie van de beurs. De parallellen tussen de theorie van optimale investeringen op de beurs en de informatietheorie zijn opvallend. Het is mogelijk de theorie van optimale investeringen af te leiden uit de informatietheorie.

8

Complexiteit van berekeningen contra communicatie Bij het bouwen van steeds grotere computers met steeds kleinere componenten botsen we op de berekeningslimiet en de communicatielimiet. De berekeningen zijn begrensd door de communicatie en de communicatie is begrensd door de berekeningen. Berekeningen en communicatie zijn dus met elkaar verstrengeld, en alle ontwikkelingen in de communicatietheorie via de informatietheorie hebben dus een directe impact op de theorie van de berekeningen.

1.2 Digitale communicatie Hoewel de informatietheorie raakvlakken heeft met verschillende domeinen, zal in deze cursus enkel worden gekeken naar de toepassingen in de digitale communicatie. Het digitaliseren van data heeft een aantal voordelen ten opzichte van analoge systemen. Ten eerste zijn digitale signalen minder gevoelig aan ruis en stoorsignalen. Door het digitale karakter van de informatie kan men op een eenvoudige manier extra informatie - redundantie - toevoegen die kan gebruikt worden om fouten geïntroduceerd door het kanaal of het opslagmedium te corrigeren. Dit is in tegenstelling tot de analoge communicatie, waar het toevoegen v an redundante informatie voor foutcorrectie zeer moeilijk is. Ten tweede zijn digitale systemen veel eenvoudiger te implementeren dan analoge systemen. Wegens de betere performantie die men kan bekomen met digitale communicatie, en de eenvoudige implementatie van digitale systemen verdringt digitale communicatie stilaan analoge communicatie. Bij digitale communicatie wordt de informatie omgezet in enen en nullen, corresponderend met de 'aan' en 'uit'-toestanden in de halfgeleidercomponenten. De overgang van analoge naar digitale communicatie bracht een aantal veranderingen teweeg in de manier waarop de informatie wordt verwerkt. In het dagelijkse leven is het grootste deel van de informatie analoog (vb. spraak, muziek, beelden, ...) aangezien dit de enige manier is waarop de mens informatie kan waarnemen. Deze analoge informatie moet omgezet worden in digitale informatie, d.i. een sequentie van enen en nullen. De digitale sequentie kan d an op een geschikte manier worden opgeslagen (vb. muziek op CD) of verstuurd over een kanaal (vb. digitale telefonie). De digitale informatie moet uiteindelijk terug worden omgezet naar analoge informatie, zodat de mens in staat is de informatie waar te nemen. Het algemeen blokschema van een digitaal communicatiesysteem wordt getoond in figuur 1.2. De data die we wensen te versturen over deze verbinding kan afkomstig zijn van een analoge bron of een digitale bron. In het geval van een analoge bron moet de data eerst worden omgezet in digitaal formaat. Deze omzetting van een analoog signaal naar een digitale sequentie gebeurt met een analoog naar digitaal (A/D) omzetter, die het analoge signaal bemonstert en door een quantizator stuurt. Door het quantizeren van het analoge bemonsterde signaal zal het signaal niet perfect kunnen gereconstrueerd worden; -

-

er treedt een afwijking op - de distorsie. De A/D-omzetter moet zo ontworpen worden dat de distorsie minimaal is. Door bemonstering en quantizatie k an een analoge bron worden omgezet ineen equivalente digitale bron. De digitale sequentie vanuit de bron bevat meestal veel redund antie. We willen de uitgang van de digitale bron op een efficiënte manier versturen over de verbinding, m.a.w. we willen de uitgang van de bron omzetten in zo min mogelijk bits. Dit doet men door alle redundantie aanwezig in de bronuitgang weg te nemen. De efficiënte omzetting van een analoge of digitale bron in een sequentie van bits wordt broncodering of datacompressie genoemd. Het effect v an de broncodering is dat aan de uitgang v an de bronencoder alle digitale symbolen statistisch onafhankelijk zijn en evenveel voorkomen. Bij bepaalde verbindingen, zoals secure internet voor thuisb ankieren of beveiligde internethandel, zal men de uitg an g van de bronencoder vercijferen. Deze vercijfering of encryptie zorgt dat de data die verstuurd wordt over de verbinding geheim is voor derden en enkel k an gelezen worden door de juiste bestemmeling. De theorie van de encryptie is eveneens nauw gerelateerd a an de informatietheorie. De kanaalencoder maakt gebruik van de (geëncrypteerde) uitgang v an de bronencoder om op een controleerbare manier redund antie toe te voegen. Deze redundantie kan gebruikt worden a an de ontvanger om de effecten van ruis en interferentie veroorzaakt door het versturen van de informatie over het kanaal tegen te gaan. De redundantie die toegevoegd wordt door de kanaalencoder dient dus om foutcorrectie aan de ontvanger te kunnen toepassen, zodat de betrouwbaarheid van de transmissie verbetert. De sequentie van bits aan de uitgang van de kanaalencoder moet eerst omgezet worden naar een geschikt signaal dat kan verstuurd worden over het fysische kanaal of golfvormkanaal. De omzetting v an de bitsequentie naar een golfvorm gebeurt met de digitale modulator.

Het golfvormkanaal is het fysische medium waarover het datadragend signaal naar de ontv an ger wordt gestuurd. Voor verschillende toepassingen worden verschillende fysische media gebruikt, zoals de atmosfeer (vrije ruimte) voor mobiele communicatie en satellietcommunicatie, elektrische kabels (twisted pair of coax) voor o.a. telefonie en kabeltelevisie, optische vezels voor communicatiesystemen die een laag transmissieverlies vereisen, en microgolfkanalen voor draadloze communicatie. De bronencoder, encryptie, kanaalencoder en de digitale modulator vormen samen de zender, terwijl de brondecoder, de kanaaldecoder, de decryptie en de digitale demodulator de ontvanger vormen. De digitale demodulator zet de golfvormen aan de uitgang van het golfvormkanaal terug om naar een sequentie van symbolen in de discrete tijd. Deze sequentie van symbolen wordt gebruikt door de kanaaldecoder om een schatting te maken van de verstuurde bitsequentie, fouten te detecteren en eventueel te corrigeren. De goede werking van de demodulator en kanaaldecoder hangt af van de aanwezigheid v an een synchronizator en egalisator. In de egalisator wordt een schatting gemaakt van de vervorming geïntroduceerd door het kanaal, 10

Digitale bron

r

Bron encoder Analoge bron

A/D

^

Kanaal encoder

Encryptie

Modulator

^

1 ARQ

-j Synchronisatie 4

4 Fout detectie Digitale informatie

4—

r

Bron decoder Analoge informatie

Egalisatie

4--

D/A

r

4--

Decryptie

Kanaal decoder

4—

Demodulator

•

golfvorm kanaal

waarna men deze vervorming tracht te compenseren. De synchronizator maakt een schatting van de frequentie en fase van de draaggolf waarop men het datadragend fysisch signaal heeft gemoduleerd. Een voorbeeld van draaggolfcommunicatie is mobiele telefonie, waarbij het spraaksignaal wordt gemoduleerd op een draaggolf met frequentie 900 MHz (GSM) of 1800 MHz (UMTS). Verder maakt de synchronizator een schatting van de symbooltiming, om te weten wanneer de ontvanger de golfvorm moet bemonsteren. Goede schattingen van deze parameters zijn nodig omdat de performantie van het communicatiesysteem sterk afhangt van deze parameters. De aanwezigheid van een synchronizator en een egalisator is dus cruciaal voor de werking van een communicatiesysteem. Een ander belangrijk kenmerk van een digitaal communicatiesysteem is de mogelijkheid tot automatic repeat request (ARQ). Indien de ontvanger de fouten geïntroduceerd door het kanaal niet kan corrigeren maar wel detecteren, dan vraagt de ontvanger via een return kanaal de retransmissie van de foutieve data. De aanwezigheid van ARQ kan de kwaliteit van de transmissie sterk verbeteren, maar brengt een inherente vertraging met zich mee. Daarom is het return kanaal, nodig voor ARQ, niet altijd aanwezig of soms zeer onpraktisch. Bijvoorbeeld bij de Voyager-missie naar de rand van ons zonnestelsel is ARQ nagenoeg onmogelijk aangezien het uren duurt vooraleer de data a ankomt. Verder is bij spraakgecodeerde signalen ARQ onmogelijk om een gelijkaardige reden: bij spraak is een maximale vertraging van typisch 200 ms toegelaten. Bij broadcastsystemen (bijvoorbeeld radi o- of televisie-uitzendingen) is ARQ uitgesloten om evidente redenen. Kanaalcodering zonder ARQ noemt men forward error correcting (FEC) codering. FEC is heel wat moeilijker te implementeren dan gewone foutdetectie met ARQ, maar heeft geen return kanaal nodig. Dikwijls worden FEC en ARQ samen gebruikt in hybride systemen voor datacommunicatie. Indien de bitsequentie vercijferd is, moet de bitsequentie aan de uitg an g van de kanaaldecoder worden ontcijferd (decryptie). Deze ontcijfering k an enkel gebeuren indien de bestemmeling de juiste sleutel heeft. A an de hand van de resulterende bitsequentie moet de oorspronkelijke data op een unieke manier worden gereconstrueerd. Dit gebeurt in de brondecoder. Indien de informatie afkomstig was van een analoge bron, wordt de sequentie a an de uitgang van de brondecoder terug omgezet naar een analoog signaal met een digitaal-naar-analoog (D/A) omzetter. In deze cursus bestuderen we enkel de broncodering en de kanaalcodering. We leiden theoretische limieten af voor datacompressie en het debiet dat men kan versturen over een kanaal aan de hand van de informatietheorie. Verder komen praktische codeertechnieken voor broncodering en kanaalcodering aan bod.

12

Hoofdstuk 2 Definitie van informatiemaat 2.1 Mutuele informatie en eigeninformatie Om een geschikte maat voor de informatie gegenereerd door een toevalsproces te bepalen, beschouwen we het volgende voorbeeld. Beschouw twee discrete toevalsgrootheden met mogelijke uitkomsten xi , i = 1, 2, ... , n, en yi, i = 1, 2, ... , m. Stel dat we Y = yi observeren en dat we de hoeveelheid informatie willen bepalen die de gebeurtenis Y = y i ons levert over de gebeurtenis X = x i , i = 1, 2, ... , n; door waarneming van Y verandert onze kennis omtrent X. Indien X en Y statistisch onafhankelijk zijn, dan levert het optreden van Y = yi geen informatie over het optreden van de gebeurtenis X = x i . Anderzijds, indien X en Y volledig van elkaar afhangen, zodat het optreden Y = yi het optreden van de gebeurtenis X = x i bepaalt, dan wordt de informatie-inhoud bepaald door de gebeurtenis X = xi. Een geschikte maat voor de informatie, die aan deze voorwaarden voldoet, is gegeven door de verhouding van de conditionele probabiliteit P(X = xi|Y = yi ) FE P(xi|yi) tot de probabiliteit P(X = xi) __ P(xi ). M.a.w. we definiëren de informatie-inhoud die de gebeurtenis Y = yi ons levert over de gebeurtenis X = x i als P(xi|yi)

I (xi; yi) = log P(xi ) •

(2.1)

I (xi ; yi ) wordt de mutuele informatie tussen xi en yi genoemd. Meestal gebruikt men de basis 2 voor het logaritme, zodat de mutuele informatie uitgedrukt wordt in bits. Indien de natuurlijke logaritme wordt gebruikt (met basis e) wordt de mutuele informatie uitgedrukt in nats. Indien de toevalsgrootheden X en Y statistisch onafhankelijk zijn, d an geldt P(xi| yi) = P(xi ) zodat I(xi ; yi) = 0. Anderzijds, indien het optreden van de gebeurtenis Y = y i op een unieke wijze het optreden van de gebeurtenis X = x i bepaalt, dan is P(xi yi ) = 1, zodat log (2.2) I (xi; yi) = log P ( xi)

13

_ — P(xi).

Hierbij is (2.2) de informatie van de gebeurtenis X = xi . Daarom wordt het de eigeninformatie genoemd van X = xi, en genoteerd als

/(x i ) = log P(xi) = — log P(xi ).

(2.3)

Merk op dat een gebeurtenis met een hoge probabiliteit minder informatie bevat dan een gebeurtenis met een lage probabiliteit. Verder is het zo dat indien er slechts één mogelijke gebeurtenis x is met probabiliteit P(xi)) = 1, dan geldt 1(x) = 0. Passen we de Bayes regel toe op het argument van (2.1), dan vinden we P(xi| yi) P(xi)

=

= P(yi|xi) P(xi)P(yi) P(yi) P(xi, yi)

Hieruit volgt dat I (xi; yi) = /(y 2 ; xi), m.a.w. de informatie geleverd door het optreden van de gebeurtenis Y = y i over het optreden van de gebeurtenis X = x i is gelijk aan de informatie geleverd door het optreden van de gebeurtenis X = x i over het optreden van de gebeurtenis Y = yi Naast de definitie van de mutuele informatie en de eigeninformatie, is het nuttig het begrip conditionele eigeninformatie te definiëren als I(xi|yi) = log

P(xi|yi)

—

log P(xi|yi)•

(2.4)

Door het combineren van (2.1), (2.3) en (2.4) vinden we het verb an d I(xi;yi) = I(xi)—I(xi|yi) = a priori informatie — a posteriori informatie.

(2.5)

We interpreteren I(x i |yi) als de eigeninformatie van de gebeurtenis X = x i na observatie > 0, volgt hieruit dat van de gebeurtenis Y = N. A an gezien zowel I(x i ) > 0 als I(xi |yi) _ I(x i ; yi ) < 0 wanneer I(x i ) < I(xi |yi), en I(xi; yi) > 0 wanneer I(x i ) > I(xi |yi). Dus, de mutuele informatie tussen twee gebeurtenissen kan positief, negatief of nul zijn. Het resultaat X, Y van een gecombineerd experiment kan beschouwd worden als één enkel vectorresultaat, waarvoor men de eigeninformatie kan definiëren als I (xiyi) = — log P(xi, yi).

(2.6)

I (yi|xi I (xiyi) = II(xi) I(xi)+I (xi)+ +I(yilxi)= (yi|xi)= )=I(yi )+ I( xi|yi) ( xi )xiyi) •

(2.7)

Hieruit volgt dat

14

Voorbeeld: We beschouwen het binair symmetrisch kanaal (BSC), getoond in figuur 2.1(a). Het binair symmetrisch kanaal is een kanaal waarvan de ingang de waarden x 1 en x2, en de uitgang de waarden y i en y2 kan aannemen (= binaire karakter). De kans dat de uitgang van het kanaal gegeven is door y i wanneer de ingang van het kanaal xj is, noemt men de kanaalprobabiliteit of overgangsprobabiliteit P(y i|xj) van het kanaal. Bij een binair symmetrisch kanaal geldt: P(y1|x1) = P(y2|x2) = 1 — e P(y1|x2) = P(y1|x2) = e.

Stel dat x 1 en x2 even waarschijnlijke toevalsgrootheden zijn, namelijk P(x i ) = P(x2 ) = 1/2. In dat geval is de mutuele informatie tussen xi en yi gegeven door log 2(1 — e) i = j I(xj; yi) = ,i,j=1,2. log 2e De mutuele informatie wordt getoond in figuur 2.1(b). Bijzondere gevallen: 1. e = 0: ruisloos kanaal. Hiervoor geldt I(x 1 ; yi) = I(x2; y2) = 1 bit en I(x i ; y2 ) = I(x2 ; yi) = —oo. Het waarnemen van y i lost de onzekerheid omtrent xi volledig op. Omtrent xi , j i krijgen we negatieve informatie: de ontvanger is misleid omdat hij aan de uitgang yi de ingang xi zal associëren. 2. e < 1/2. Hiervoor geldt 0 < I(x i ; yi ) < 1 en I(xj; yi ) < 0, i # j, i j = 1, 2. We zijn niet meer zo zeker dat X = 3. e = 1/2. Hiervoor geldt /(x 3 ; yi) = 0, i, j = 1, 2. De ingang en de uitgang van het kanaal zijn statistisch onafhankelijk. Het waarnemen van Y levert geen informatie over X. ,

2.2 Gemiddelde mutuele informatie en entropie De mutuele informatie in (2.1) is gedefinieerd over de resultaten xi en yi van een experiment. De mutuele informatie is dus een toevalsgrootheid. Haar verwachtingswaarde over alle resultaten x3 en yi wordt de gemiddelde mutuele informatie genoemd, en is gedefinieerd als n m

/(X; Y)

Et/ (xi;

y,i)1 = E EP(xi, yj)I(xi;

_

i =1

n m

E E P(xi, yi) log

i=1

15

yi)

j =1

j =1

P(xi, y^ ) P(xi)P(yj) •

(2.8)

1-c (a)

(b) Figuur 2.1: (a) Binair symmetrisch kanaal (b) Mutuele informatie bij binair symmetrisch kanaal

16

1 0.9 0.8 0.7 0.6 ^ 0.5 0.4 0.3 0.2 0.1 0

0

0.5

1

E

Figuur 2.2: Gemiddelde mutuele informatie bij een binair symmetrisch kanaal Merk op dat I(X; Y) = 0 wanneer

X en Y statistisch onafhankelijk zijn.

Voorbeeld 1: Voor het binair symmetrisch k an aal uit figuur 2.1(a) met even waarschijnlijke ing an gen x 1 en x2 is de gemiddelde mutuele informatie gegeven door /(X; Y) _ (1 — E) loge 2(1 — c) + E logt 2E bits. De gemiddelde mutuele informatie voor een binair symmetrisch kanaal is getoond in figuur 2.2. Voorbeeld 2: Een binair er as ure kanaal (BEC) is een kanaal met twee mogelijke ingangen x 1 en x2 , en drie mogelijke uitgangen y i , y2 en e, zoals getoond in figuur 2.3(a). De uitgang e van het kanaal komt overeen met een erasure: het kanaal kan niet beslissen wat de ingang van het kana De kanaalprobabil zijn gegeven dP(y2| P(y1|x i) P(yilxi) = P(|2jx2) = 1 — P(e|xi) P(eIx i ) = P(elx 2) = e P(y2I xi) = P(yi I x2) = O. Beschouwen we het geval dat de twee mogelijke ingangen x 1 en x2 even waarschijnlijk zijn (P(xi) = P(x2) = 1/2), dan vinden we de gemiddelde mutuele 17

(a) 1 0.9 0.8 0.7

0.6 ^ .

0.5 0.4 0.3 0.2 0.1 0 0.5

0

1

s

(b) Figuur 2.3: (a) Binair er as ure kanaal (b) Gemiddelde mutuele informatie voor een binair er as ure kanaal

informatie I(X; Y) = (1 — E) bits.

De gemiddelde mutuele informatie voor een binair erasure kanaal is getoond in figuur 2.3(b).

18

Op een zeer gelijkaardige manier definiëren we de gemiddelde eigeninformatie n

H(X) = >P(xi)I(x i ) i=1 n = —

E P(xi ) log P(xi ) .

(2.9)

i=1

De gemiddelde eigeninformatie wordt ook wel de entropie van het toevalsproces genoemd. Zoals in het volgende hoofdstuk zal worden aangetoond, is de entropie van een discreet toevalsproces een maat voor de complexiteit van een toevalsproces, of het aantal bits waarmee men de uitkomst van het toevalsproces minstens moet voorstellen. De g delde conditionele eigeninformatie word is gegeven door n

H(X 1Y) =

e conditionele entropie genoemd en

m

|y3) • E E=1 P(x i , yy) log P(x Iy3)

(2.10)

i=1 3

We interpreteren H(X IY) |Y) als de informH(X|Y) f onzekerh X nadat Y geobserveerd werd. Combineren we (2.8), (2.9) en (2.10), dan vinden we het verband

I(X; Y) = H(X) — H(XIY) = H(Y) — H(YIX) H(Y|X)

(2.11)

onzekerheid gecreëerd door het kanaal. Beschou Y van een gecombineerd experiment als één enkel vectorresultaat met eigeninformatie (2.6), dan geldt

H(XY) = H(X)+H(YIX)=H(Y)+H(XIY) H(X)+H(Y|X)=H(Y)+H(X| Y) I(X; Y) = H(X) + H(Y) — H(XY) < H(X) + H(Y). Voorbeeld 3: Beschouwen we een experiment dat een sequentie van statistisch onafhankelijke bits verstuurt met probabiliteiten P(X = 0) = q en P(X = 1) = 1 — q. De entropie van dit experiment is

H(X):_- 1-1(q) = —q log q — (1 — q) log(1 — q). De functie 1-l(q) wordt de binaire entropiefuntie genoemd. De entropie wordt getoond in figuur 2.4. We merken op dat de entrop l wordt 1/2, waa 9-1(1/2) = 1 n ) =de bits over een binair symmetrisch kanaal met kanaalprobabiliteiten P(Y=O|X=0) = 1—p P(Y=OIX=0) P(Y=OIX=1) =p P(Y=O|X=1 P(Y = 1| 1I X = 0) = p P(Y=1IX=1) P(Y=1|X=1) = 1 — p.

19

(2.12)

H(X) = en tropie in bits/symbool

0

0.2

0.4

0.6

0.8

1

q = probabiliteit van X=0

Figuur 2.4: Binaire entropie De conditionele entropie wordt getoond in figuur 2.5 en de gemiddelde mutuele informatie in figuur 2.6. We kunnen de bovenstaande theorie uitbreiden naar meer dan twee toevalsgrootheden. Beschouw een vector van k toevalsgrootheden X 1 , X2 , ... , Xk met gezamenlijke probabiliteit P(x l , x2i ... , xk) = P(X 1 = x1 , X2 = x2 ) ... , Xk = Xk). Dan geldt dat de mutuele informatie over x 1i geleverd door de waarneming van x2, ... , x k gegeven is door logg

I (xl; x2, • • • , xk)

= log

P(xi)

P(xllx2) P(x1 | x2, x3) P (x l ) P(x1l l| x2) P(x

1 P(x |x2, ... , xk)

P(x1| P(x1 I x2 i • , xk -1) +...+I(xl;xk|x2,... I (xl;xk lx2, x k-1)• = I (x (xll;; x2) + l; x3l x2 ,xk-1)• + I(xl;x3| x2)) +...+

(2.13)

• •

...,

Eveneens geldt dat de gezamen

e eigen

matie gegeven is door

+I(x2| x1)+...+ I(xktxi,...,xk-1)• , ... ,xk-1)•

(2.14)

Na uitmiddeling vinden we I(Xl ; X2i ... , Xk) = I (Xl; X2) + /(X1; X3I X2) + ... +

20

X k|

(2.15)

H(XIY) = conditionele en tropie

0

0.2

0.4

0.6

0.8

1

q = p robab iliteit van X=0

I(X;Y) = gemiddelde mutuele informatie

Figuur 2.5: Conditionele entropie voor binaire bron, binair kanaal

0

0.2

0.4

0.6

0.8

1

q = probabiliteit van X=0

Figuur 2.6: Gemiddelde mutuele informatie voor binaire bron, binair kanaal 21

De entropie van de vector is gegeven door nl

11 (X1,

nk

n2

...

X2, ... , Xk) = —

^ P(x j1,x72,..., xi k ) log P(x;1,x;2,...

ik =1

.71=1.72=1

'

xik).

(2.16)

Aangezien de gezamen lijke probabiliteit P(x l , x2i ... , x k ) ontbonden kan worden als P(xl, x2, ... , xk) = P(xi)P(x2| xi)P(x31 x1, x2) • • • P(xk| xl, x2, • • • , xk-1),

vinden we dat H (X l,

H(X2|X1) 2 IX 1 ) + H(X31 X1, X2) X2, . . . Xk ) = H(Xl) + H(X H(Xk| +. .. + H(XkI X1, X2, . .. , Xk -1) H(Xk|H(Xk| ,

k =

^ H(XiIX1,X2,...,X{_1)•

(2.17)

i =1

Voorbeeld 4 : We beschouwen een binair symmetrisch kanaal zonder geheugen, zoals getoond in figuur 2.1(a). Geheugenloos betekent dat de uitgang van het kanaal op een tijdstip enkel afhangt van de ingang van het kanaal op het beschouwde tijdstip, maar niet van de ing an gen op andere tijdstippen. Stel dat de ingang van het k an aal gekozen wordt uit twee mogelijke berichten x 1 = (x ii xi , xi ) en x2 = (x2i x2 , x2). De uitg an g van het kanaal is gegeven door y = (y2, yi, y i ). Dan vinden we dat de mutuele informatie v an x na observatie r van de uitgang y op de v hillende tijdstippen gegeven is Ix1;y1( x l;

y2) =

log 2e < 0

Ix1;Y2IYi (x1; y11y2) = log

Px1lY2Yi

(xi 1y1, y2)

1y2) 1Y2)

_ — log 2e

Dit betekent dat Ix1;Y2,Y1(xl;yi, Yi,y2) Y2) = 0. Dit is logisch aangezien na ontvangst van y2, yi de ontvanger nog niet meer weet over X 1 dan voordien. Tenslotte is Ix,;Y31Y1,Y2 (xi; 1y2, y1) = log 2(1 — e) > 0

2.3 Eigenschappen van entropie en mutuele informatie Eigenschap 1: Indien de stochastische variabele X één uit K mogelijke waarden kan opie aannemen, dan is z H(X) < lH(X3| (2.18) jk zijn. met gelijkheid indien alle waa^H(Xi|X1,X2,...,X{_1)• 22

Beschouwen we het speciale geval waarbij alle mogelijke uitkomsten van de bron dezelfde waarschijnlijkheid hebben, P(xi ) = 1/K, i = 1, 2, ... , K, dan vinden we H(X) = log K. (2.19) Steunen we op de eigenschap dat In z < z — 1, z > 0, dan kan men op een eenvoudige wijze bewijzen dat H(X) < log K, voor om het even welke set van probabiliteiten P(xi ), i = 1, 2, ... , K. M.a.w. de entropie van een experiment is maximaal wanneer alle mogelijke uitkomsten dezelfde waarschijnlijkheid hebben.

_

Eigenschap 2: De entropie H(X) stijgt wanneer de waarschijnlijkheid van een uitkomst vergroot ten koste van een uitkomst met grotere waarschijnlijkheid. Als voorbeeld voor deze eigenschap beschouwen we een binair experiment dat een sequentie van statistisch onafhankelijke bits genereert met probabiliteiten P(X = 0) = q en P(X = 1) = 1—q. De entropie van dit experiment is gegeven in voorbeeld 3 in de vorige sectie en deze entropie wordt getoond in figuur 2.4 als functie van q. Uit deze figuur zien we dat wanneer q toeneemt (q < 1/2), de entropie inderdaad toeneemt. In het algemeen zal door de waarschijnlijkheid van een uitkomst te vergoten ten koste van een uitkomst met grotere waarschijnlijkheid, het speciale geval waarbij alle uitkomsten van de bron even waarschijnlijk zijn dichter benaderd worden, zodat de onzekerheid over de uitkomst zal toenemen. Eigenschap 8: Bij een gezamenlijk experiment X, Y is de gemiddelde mutuele informatie nooit negatief. Ze is nul als en slechts als X en Y statistisch onafhankelijk zijn.

I(X; Y) > 0.

(2.20)

Deze eigenschap kan bewezen worden door gebruik te maken van de eigenschap ln z 0. Aangezien I(X; Y) > 0 volgt hieruit dat H(X) > H(X|Y), met gelijkheid enkel en alleen indien X en Y statistisch onafhankelijk zijn. Indien we H(X |Y) interpreteren als de gemiddelde hoeveelheid onzekerheid in X na observatie van Y, en H(X) als de gemiddelde hoeveelheid onzekerheid voor de observatie, dan is I(X; Y) de gemiddelde hoeveelheid onzekerheid geleverd over X door de observatie van Y. Het is duidelijk dat conditioneren op de observatie Y de entropie niet doet stijgen, aangezien H(X) > H(X|Y). Passen we H(X) > H(X|Y) toe, waarbij X = Xm en Y = Xi , X2 , ... , dan volgt uit (2.17) dat k

1 (X1, X2, ..., Xk) C E H(Xm m= 1 23

z

X

Y

kanaal 1

kanaal 2

{zt}

Figuur 2.7: Kanalen in cascade waarbij de gelijkheid enkel optreedt indien de toevalsgrootheden X 1 , X2, . . , Xk statistisch onafhankelijk zijn, m.a.w. P(x i , x2 , ..., x k ) = P(x i )P(x2 ) ... P(xk ). .

Eigenschap

4 : Bij een P(P(x,y|ze X, Y, Z is (2.21)

gezI(X;Y|Z I(X;YIZ dien P(P( P(x,ylz) x,y|z = P(xlz)P(ylz). met P(x|z)P(y|z). Dit is een rechtstreeks gevolg van eigenschap 3. Uit eigenschap geziX|), I(X; YIZ) Y|ZY|Z)t = H(XIZ) H(X|Z)))— H(

(2

geldt dat ||||YZZ), H(XIZ) |||Z) > H(XlYZ),

(2.23)

P(xz)P(ylz). en P(x, y}z) = P(x|z)P(y|z|z).

met g

Een toepassing van deze eigenschap is het bepalen van de mutuele informatie en de entropie van een cascade van twee kanalen. Beschouwen de twee kanalen r 2.7. Stel P(ylz) P(y|z) = P(ylzx), m.a.w. de uitgang van ls P(y|zx), in casca kanaal 2 hangt enkel af van de ingang kY| Y||

P(x, y|z)

PP(x|z).x |yzPPPPPPPPP(x|yz P(x P(x|z). P zodat P(xlyz) PP(Y| = P(xlz). P(xY| PPPPP(x|yz) PPPPPPP(x|yz) PPPPP(x|yz) = PPPP PPPPP PPPPPP PP(x|z). x|yz) xlyz)

Men heeft

s sZ|Y) + I(X; ZIY) YIZ) ;Z)+ Y|Z) = I(X;Z). II(X = I(X;Z)+

Daar I(X; ZIY) Z|Y) > 0 is Z|Y)

I(X;Z) > I(X;Y). ns

P(x|z)P(y|z) in x en y geldt analoog van P(x, ylz) y|z) = P(xlz)P(ylz)

I(Y; Z) > I(Y; X) = I(X;z l). 24

De mutuele informatie tussen X en Z en tussen Y en Z kan dus niet kleiner zijn dan tussen X en Y, wat intuïtief te verwachten was. Verder geldt H(X) — H(X|Z) > H(X) — H(X|Y) H(X|Z) <

H(X|Y).

De gemiddelde onzekerheid omtrent de ingang van het kanaal bij gegeven uitgang zal niet verminderen wanneer men vanaf de ingang doorheen een cascade van kanalen gaat. Deze gemiddelde onzekerheid omtrent de ing an g, bij gegeven uitgang, heet de dubbelzinnigheid van het k an aal. Een andere interpretatie die men a an een cascade van kanalen k an geven is de volgende. Het eerste kanaal is het werkelijke k an aal, en het tweede kanaal is een dataprocessor. De dataprocessor kan dus de onzekerheid omtrent de ingang van het kanaal, bij gegeven uitgang niet verminderen, noch de mutuele informatie vermeerderen. Een dataprocessor is echter vaak nodig om de uitgang van het kanaal nuttig te kunnen gebruiken (= dataprocessortheorema).

2.4

Informatiemaat voor continue toevalsgrootheden

De definitie van mutuele informatie die hierboven gedefinieerd is voor discrete toevalsgrootheden kan op een eenvoudige wijze uitgebreid worden naar continue XetonYvalswgrchdiu.Stoenzjmgalikedstrbu p(x, y) en marginale distributies p(x) en p(y), dan is de gemiddelde mutuele informatie gedefinieerd als +00+00 +00+00

/(X;

=

Y)

f

(x)p(yI (y| x) log (x)p

^ ^ ^

p(yI x)p(x) p(y| .

p(x)p(y) dxdy

(2.24)

Hoewel de gemiddelde mutuele informatie eenvoudig kan gedefinieerd worden voor continue toevalsgrootheden, is dit niet mogelijk voor de eigeninformatie. Het probleem is dat een continue toevalsgrootheid een oneindig aantal bits nodig heeft om exact voorgesteld te kunnen worden. Hieruit volgt dat de eigeninformatie oneindig groot is, waaruit volgt dat zijn entropie ook oneindig is. Desondanks definiëren we een grootheid die we de differentiële entropie noemetoevalsgro theden van de continue toevalsgro theid nXl,. +00

H(X ) = — Verder defi

we de conditionele e H(X|Y)= — J H(XIY)

J

p(x)

log p(x)dx.

(2.25)

^

pie van X indien Y gegeven is

r+00 +00

(2.26) p(x|I y)dxdy. f p(toevalsgrootheden,toevalsgrootheden ytoevalsgrootheden 00

25

Y N kanaal Figuur 2.8: Additief Gaussiaans kanaal Hieruit volgt dat de gemiddelde mutuele informatie kan geschreven worden als

I(X;Y) = H(X) — H(X|Y) = H(Y) — H(Y|X). Voorbeeld 1: Beschouw twee statistisch onafhankelijke Gaussiaanse toevalsgrootheden X en N, met gemiddelde nul en de varianties van X en N zijn respectievelijk gelijk aan E en v2 . De distributie van x en n is gegeven door 1

p(x) =

_ ,2

2E

7rE e 1

p(n) =

n2

e 2—z

.

2 ^ rv

De uitgang van het kanaal (zie figuur 2.8) bestaat uit de som van de ingang x en de toevalsgrootheid n: y = x+ n. De distributie van y is gegeven door 1

p(y) =

V2ir(E + U2 )

E+o , e 2( 2)

De entropie van X en Y zijn gegeven door H(X) =

2 log(27reE)

H(Y) = 2 log(27re(E + 0 2 )). Daar H(Y) = H(X) indien y = x + a, waarbij a een constante is, en daar Y Gaussiaans verdeeld is met gemiddelde x en variantie U 2 , is H(Y | X) = log(27recr2 ). Daarom is de mutuele informatie tussen X en Y gegeven door

I(X; Y) = 21 og(27re(E + 0•2 )) — o2 1

g(2rrev2 ) = g lo (1 +

2

^2

).

co, wat we verwachtten, a an gezien de x en I(X; Y) Als o --* 0, dan y eigeninformatie van elk X-resultaat (niet de entropie volgens (2.25)) oneindig is.

26

In sommige gevallen is de toevalsgrootheid X discreet en Y continu. Bijvoorbeeld X kan de waarden x i i = 1, 2, ... , n aannemen en Y wordt beschreven door zijn marginale distributie p(y). Wanneer X en Y statistisch afhankelijk zijn van elkaar, dan kunnen we p(y) schrijven als volgt: ,

n

p(y) = Ep(y|xi)P(xi)• i=1

De mutuele informatie geleverd over de gebeurtenis X = xi door het optreden van de gebeurtenis Y = yi is gegeven door log

I(xi; TJ) =

p(y| xi) P (xi)

p(y) P ( xi)

= log ' yixi)

.

p(y)

De gemiddelde mutuele informatie wordt dan

/(X;

_ n Y) — ^ i=1

f

+ oo oo

pxi) (y)) dy p(yixi)P(xi) log p(y

Voorbeeld 2: Stel dat X een discrete toevalsgrootheid is met twee even waarschijnlijke uitkomsten x 1 = A en x2 = —A. De conditionele distributies p(y| xi), i = 1, 2 is Gaussiaans met gemiddelde x i en variantie o. 2 : e

1

p(y| A) =

20 ^ 2

`^

r6 A)2 1 e `a'

p(y| — A) =

2iro

De gemiddelde mutuele informatie wordt dan

( y|A) , Y) _ 1 + [p(yIp g p(y| +p(yI (y| +p 2 2^^[ I (X ^ )

^

p( y)

=

2

A) lOg p

A) + p( p(yI y| - A) 1 • y|p1p(A)

27

(yI

p (y|

^

l

dy

Hoofdstuk 3 Broncodering 3.1 Inleiding Communicatiesystemen worden ontworpen om informatie gegenereerd door een bron naar één of meerdere bestemmingen te sturen. Bronnen van informatie kunnen onderverdeeld worden in verschillende klassen. Bijvoorbeeld, bij radio-uitzendingen is de bron meestal een audiobron (spraak of muziek). Bij televisie-uitzendingen is de bronuitgang een bewegend beeld. De uitgangen van deze bronnen zijn analoge signalen, en deze bronnen worden dan ook analoge bronnen genoemd. Daartegenover staan bronnen zoals computers en opslageenheden, zoals optische of magnetische schijven. Deze bronnen produceren een discrete uitgang (meestal binaire of ASCII karakters), en worden discrete bronnen genoemd. Ongeacht of een bron analoog of discreet is, wordt een digitaal communicatiesysteem ontworpen om de informatie op een digitale manier te versturen. Hieruit volgt dat de uitgang van de bron omgezet moet worden in een bitsequentie. Deze omzetting van de bronuitgang naar een bitsequentie wordt uitgevoerd door de bronencoder. In dit hoofdstuk beschouwen we broncodering gebaseerd op wiskundige modellen voor de bronnen, en we leiden een maat af voor de informatie die door een bron wordt uitgezonden. Verder beschouwen we codeertechnieken voor discrete bronnen. Daarna zullen we voor analoge bronnen de optimale quantisatie beschouwen, en de rate-distortion theorie behandelen, die aangeeft welke minimale distorsie kan bekomen worden bij een bepaald debiet. Eerst beschouwen we enkele wiskundige modellen voor bronnen.

3.2 Bronmodellen De uitgang van een bron wordt meestal beschouwd als een stochastisch proces (of stochastische sequentie). Immers, indien de uitgang v an de bron exact gekend is, moet deze informatie niet verzonden worden, aangezien de ontvanger in dat geval de informatie reeds 28

kent. Het stochastisch model is een goed wiskundig model voor vele bronnen en levert de mogelijkheid tot efficiënte broncodering. Een bron die een bericht produceert, maakt in feite een keuze onder een aantal mogelijke berichten. Deze keuze wordt (althans voor de ontvanger) probabilistisch ondersteld.

3.2.1 Discrete geheugenloze bronnen Het eenvoudigste bronmodel is een bron die een sequentie van symbolen genereert uit een eindig alfabet. Bijvoorbeeld, bij een binaire bron wordt een sequentie van de vorm 001101001010... gegenereerd, waarbij het alfabet bestaat uit de twee symbolen {0, 1}. Inhetalgm rndiscetbo qunvasymboleitf met K symbolen, {xk |k = 1, ... , K}. Bij de discrete geheugenloze bron is de uitgezonden sequentie statistisch onafhankelijk, namelijk een uitgezonden symbool is onafh ankelijk van de vorige en de toekomstige uitgezonden symbolen. Een bron die aan deze voorwaarde van statistische onafhankelijkheid voldoet noemt men een geheugenloze bron. Om een wiskundig model voor de bron op te stellen, veronderstellen we dat elk symbool uit het alfabet gekozen wordt met een probabiliteit pk, waarbij pk=P(X=xk),

en

1

< k
K

E pk=1. k=1

Later zullen we methoden zien om een dergelijke bron efficiënt te coderen in bits. Dat deze efficiëntie, uitgedrukt in gemiddeld aantal benodigde bits per symbool, afhangt van pk is duidelijk: veel voorkomende symbolen worden best met korte sequenties van bits gecodeerd. We zullen aantonen in dit hoofdstuk dat een belangrijk begrip voor broncodering de eigeninformatie van een symbool x k is: /(xk)

= — log2 pk (bits) = — lnpk (nats).

Er geldt dat I(xk) = 0 als pk = 1, en I(xk) is groot voor weinig waarschijnlijke symbolen. I(xk) is een informatiemaat of onzekerheidsmaat van het symbool x k . De gemiddelde waarde van I(xk) is de entropie van de bron (zie (2.9)): K

H(X) = —

E pk log2 pk (bits/bronuitg ang). k=1

Zijn alle symbolen even waarschijnlijk, dan is H(X) = log2 K bits/bronuitgang. Indien K = 2L, dan is H(X) = L. Het is dus duidelijk dat men elk van deze 2L symbolen 29

kan coderen met een L-bit sequentie. Men heeft dus L bits per symbool nodig. Uit het broncoderingstheorema zal volgen dat voor willekeurige pk en K men gemiddeld minstens H(X) bits zal nodig hebben per symbool. Leve rt de bron M statistisch onafhankelijke symbolen per seconde af, dan is de entropie van de bron, uitgedrukt in bits/seconde, gelijk aan M • H(X), en de bron kan gecodeerd worden met behulp van gemiddeld ten minste M • H(X) bits/seconde.

3.2.2 Discrete bronnen met geheugen Indien de uitgang van de discrete bron statistisch afhankelijk is, bijvoorbeeld zoals bij een Nederlandse tekst, d an kunnen we ook een wiskundig model opstellen voor de bron gebaseerd op statistische stationariteit van de bron. Bij definitie is een bron stationair w an neer de gezamenlijke distributie van een twee sequenties van lengte n, namelijk xl, x2i ... , xn en xl+m, x2+m .. • , xn+m dezelfde is voor alle waarden van n > 1 en voor willekeurige verschuivingen m. Met an dere woorden, de gezamenlijke distributie van een sequentie van symbolen van een willekeurige lengte is invariant onder een verschuiving in de tijd. ,

Men kan de entropie bepalen van een bron met geheugen (zie (2.16)). Het broncoderingstheorema is ook geldig voor ergodische bronnen, m.a.w. bronnen waarvoor de tijdsuitmiddeling en de statistische uitmiddeling hetzelfde resultaat oplevert.

3.2.3 Analoge bronnen Analoge bronnen, waarbij de uitgang van de bron op elk ogenblik een oneindig aantal mogelijke waarden kan aannemen, kunnen niet gecodeerd worden met een eindige bitstroom zonder een afwijking of distorsie toe te laten. Codeertechnieken voor analoge bronnen zullen dus steeds een distorsiemaat inhouden. Een aantal van deze technieken werden reeds besproken in de cursus 'Datacommunicatie', i.e. de uniforme quantisator en enkele technieken die steunen op de uniforme quantisator: (differentiële) puls code modulatie en delta modulatie. De theorie rond de quantisator wordt verder uitgebouwd in deze cursus: wat is een optimale quantisator en hoe kan men quantiseren in meerdere dimensies.

3.3

Codering van discrete bronnen

In hoofdstuk 2 hebben we een maat voor de informatie voor een discrete toevalsgrootheid

X gedefinieerd. Wanneer de toevalsgrootheid X de uitgang is van een discrete bron, dan stelt de entropie H(X) van de bron de gemiddelde hoeveelheid informatie voor die door de bron wordt gegenereerd. In dit hoofdstuk beschouwen we het probleem van het encoderen van de uitgang van de bron in een sequentie van bits. De efficiëntie van de encodering

30

kan worden gemeten door het gemiddeld aantal bits per bronuitgang te vergelijken met de entropie H(X) van de bron. Het encoderen van de uitgang van een discrete bron met een eindig alfabet kan op het eerste zicht een relatief eenvoudig probleem lijken. Echter, dit is enkel het geval wanneer de bron geheugenloos is, namelijk wanneer de opeenvolgende symbolen gegenereerd door de bron statistisch onafhankelijk zijn, en elk symbool afzonderlijk wordt gecodeerd. Het model van een discrete geheugenloze bron is het eenvoudigste model voor een fysische bron. Echter, er bestaan slechts weinig fysische bronnen die kunnen gemodelleerd worden met dit geïdealiseerde model. Bijvoorbeeld, de opeenvolgende symbolen van een Nederlandse tekst zijn statistisch afhankelijk. Anderzijds, indien de tekst een computerprogramma voorstelt, zal de afhankelijkheid van de opeenvolgende symbolen veel kleiner zijn. In elk geval zal aangetoond worden dat het efficiënter is om blokken van symbolen te coderen in plaats van symbool per symbool. Door het aantal symbolen per blok voldoende groot te kiezen kan het gemiddeld aantal bits nodig per symbool willekeurig dicht bij de entropie van de bron gebracht worden.

3.4 Codering voor discrete geheugenloze bronnen Stel dat een discrete geheugenloze bron een symbool produceert om de 7 -8 seconden. Elk symbool wordt gekozen uit een, eindig alfabet {x á |i = 1, ... , L}, die voorkomen met een waarschijnlijkheden pi = P(xi) i = 1, ... , L. De entropie van de discrete geheugenloze bron is dan „

(3.1) pi log e pi < log2 L, t=i waarbij de gelijkheid geldt wanneer alle symbolen eve waarschijnlijk zijn. Het gemiddeld aantal bits per symbool is H(X) en het brondebiet in bits/seconde is gedefinieerd als H(X)/T s . H(X) = —

3.4.1 Vaste-lengte codes Eerst beschouwen we een blokcodeerschema waarbij elk symbool voorgesteld wordt door een unieke set van R bits. Aangezien er L mogelijke symbolen zijn, is het aantal bits nodig om deze symbolen op een unieke wijze voor te stellen gelijk aan R = llog2 Li,

(3.2)

waarbij lx1 het kleinste gehele getal voorstelt dat groter dan of gelijk aan x is. Het codedebiet is in dit geval gelijk ',aan R, en aangezien H(X) < loge L geldt dat R > H(X). De efficiëntie van codering voor een discrete geheugenloze bron wordt gedefinieerd als de verhouding H(X)/R. We merken dat, indien L een macht is van 2 en wanneer alle 31

symbolen even waarschijnlijk zijn, R = H(X). Dit betekent dat een code waarvan de codewoorden een v aste lengte R bits/symbool hebben een efficiëntie van 100% bereikt. Indien L geen macht is van 2, maar alle symbolen even waarschijnlijk zijn, dan zal R maximum 1 bit/symbool verschillen van H(X). Indien loge L » 1, dan is de efficiëntie van dit codeerschema nog steeds hoog. Wanneer L klein is kan men de efficiëntie van de vas te lengte code verhogen door een blok van J symbolen tegelijkertijd te coderen. Om J symbolen tegelijkertijd te coderen heeft men L' verschillende codewoorden nodig. Door sequenties van N bits te gebruiken kan men 2N codewoorden bekomen. De lengte N van de sequentie moet gekozen worden zodat N > J loge L.

(3.3)

Hieruit volgt dat de minimale waarde voor N (= geheel getal) gegeven is door N = (J loge Ll .

(3.4)

Het gemiddeld aantal bits per symbool is nu gegeven door N/J = R, waardoor de inefficiëntie van de codering verminderd is met ongeveer een factor 1/J in vergelijking met het symbool-per-symbool codeerschema. Door J voldoende groot te kiezen kan de efficiëntie van het codeerschema, gemeten, door de verhouding JH(X)/N, zo dicht bij 1 brengen als gewenst. Het codeerschema dat hierboven beschreven wordt brengt geen distorsie met zich mee aangezien de codering van de symbolen naar codewoorden op een unieke manier gebeurt. Deze manier van encoderen noemt men verliesloos. Stel nu dat we het codedebiet R proberen te verlagen door niet meer strikt te eisen dat het codeerproces uniek moet zijn. Bijvoorbeeld, stel dat enkel een fractie van de LJ blokken op een unieke manier wordt gecodeerd. In het bijzonder, stel dat enkel de 2 N — 1 meest waarschijnlijke blokken van J symbolen op een unieke m an ier worden gecodeerd, terwijl de overige LJ—(2 N -1) blokken worden voorgesteld door het overblijvende codewoord. Met dit codeerschema is het onmoge lijk de oorspronkelijke symbolen te reconstrueren telkens een blok van symbolen geprojecteerd wordt op dit overblijvende codewoord. Dit resulteert in een distorsie. Noemen we Pe de probabiliteit dat er een decodeerfout optreedt. Geb as eerd op dit blokcodeerschema heeft Shannon het volgende broncoderingstheorema bewezen. Voor een discrete geheugenloze bron met eindige entropie H (X), met codering v an rijen van J symbolen in codewoorden van N bits geldt dat de probabiliteit Pe van blokken waarvoor geen unieke codewoorden zijn voorzien zo klein mogelijk k an gemaakt worden als men wil, voor elke 8 > 0 indien (3.5) R- J > H(X)+6, Broncoderingstheorema I:

en nadert tot 1, voor elke b > 0 indien R- < H(X)- ó, 32

(3.6)

wanneer J voldoende groot is.

Bewijs: We coderen een sequentie uJ = (u 1i ... , uJ) van J symbolen uit een alfabet {x i , ... , xK} in een codewoord van lengte N bits. Aangezien we te maken hebben met een geheugenloze bron, is de probabiliteit van een sequentie uJ gegeven door J

P(ur). fl P=1

P(uj) _

De eigeninformatie van deze sequentie uJ is J

J

I(uj ) = — log P(uj) = E — log P(ue) _ E gul).

8=1

P=1

Aangezien ut een stochastische variabele is met distributie afhankelijk van e, geldt hetzelfde voor gut ). De verwachting van I(ul) is H(U). Volgens de wet van de grote aantallen zal het rekenkundig gemiddelde ^é I(up)/J met grote probabiliteit H(U) benaderen als J groot is. Dus

I(uJ) N H(U), J

(3.7)

2-JH(U)

(3.8)

of

P(uj )

H(U) in bits

Voor de meeste sequenties geldt bovensta an de uitdrukking. Dit noemt men de typische sequenties: het zijn de sequenties waarvoor het rekenkundig gemiddelde van I (ue) ongeveer gelijk is aan het statistische gemiddelde. Afgezien v an enkele andere sequenties waarvoor dit niet geldt, en waarvan de waarschijnlijkheid klein is, is het aantal typische sequenties gelijk aan

Mr2JH(u)

H(U) in bits.

(3.9)

Willen we alleen de typische sequenties coderen met codewoorden van N bits, JH(U). Van daar de interdan moet gelden dat 2 N = MT of N = log2 MT pretatie van de entropie:

H(U)

—

J

logP(uJ )

j log MT N

J

met uJ = typische sequentie met MT = aantal typische rijen

N = lengte van codewoorden om typische sequenties te kunnen coderen.

33

De voorgaande benaderingen zullen we nu preciseren. Uit de definitie van de entropie volgt dat .1( uJ)1 E [

J

J

H(U),

waarbij I(uj) de som is van onafhankelijke en identisch gedistribueerde stoch astische variabelen I(ue), met verwachting H(U) en spreiding v. De ongelijkheid van Tchebychev levert voor elke S > 0

I P[

(

)

^J

2

H(U) > S c T6-2 ° e(J, (5 ), ]

dus lim j,0 e(J, 8) = 0, VS > 0. Deze uitdrukking preciseert de gemaakte benadering (3.7). Stel dat T de set van sequenties I (u j) is, waarvoor bij gegeven S en J geldt I (uJ)

J

H(U) < 8.

(3.10)

Dit noemen we de typische sequenties. Uit de bovenstaande ongelijkheid v an T gegeven is door Tchebyvolgtdaprbievnst P(T) >1 - e(J, S).

We kunnen I(uJ) begrenzen door (zie (3.10)) J(H(U) - 8) < I(uJ ) < J(H(U) + 5),

of

2-J(H(U)-6) > P(uj ) > 2 -J(H(U)+ó) .

Deze vergelijking preciseert (3.8). Met MT (J, 5) het aantal sequenties in T geldt: 1 > P(T) _

E P(uJ) >

—

alle ujET

dus

MT min P(uJ) > MT 2 -J(H(U)+6) uJ ET

MT < 2J(H(U) + 5)

Eveneens geldt ) > MT2-J(H(U)-a), 1 - c(J, S) < P(T) < MTmaxP(uJ u^E T dus MT > [1 — e(J, 5)12J(H(U)-6)

Deze grenzen voor MT preciseren (3.9). 34

We wensen nu de typische sequenties te coderen in woorden van N bits. We kiezen N zodanig dat 2N > 2J(H(U)+ó) ,

(3.11)

dus 2N > MT. Dan kunnen alle MT typische sequenties uit T eenduidig gecodeerd worden. De probabiliteit dat we sequenties hebben waarvoor we geen codewoorden meer beschikken noemen we Pe . Uit het voorgaande volgt dat Pe < «J, ó).

Indien J — oo (en N ook zodat aan (3.11) voldaan blijft) zal Pe —4 0 voor elke b > 0. Dit resultaat levert het eerste deel van het broncoderingstheorema op. Omgekeerd, we kiezen N zodat, met y > 0, het aantal codewoorden gelijk is aan 2N < 2J(H(U)-ó-7)

(3.12)

Kennen we deze codewoorden toe aan leden van T, waarvoor P(u j ) < 2 - J(H(U)-6) , dan is de totale probabiliteit van deze sequenties ten hoogste 2 - J( H ( U) - ó )2J (H ( U) - ó - 7) = 2 - J7.

Een andere strategie zou zijn de codewoorden toe te kennen aan leden buiten T, maar voor het totaal v an deze sequenties is de probabiliteit ten hoogste f(J, ó). De totale probabiliteit van sequenties waaraan codewoorden kunnen toegekend worden is dus niet groter dan 2-J7 + e(J, 6), welke strategie men ook gebruikt. Deze probabiliteit is dus 1 — Pe <2-17 + e(J, (5).

Dus dó > 0 zal, als J -4 oo, mits N voldoet a an (3.12), Pe -* 1. Dit bewijst het tweede deel van het broncoderingstheorema. 0 Uit dit broncoderingstheorema leiden we af dat het gemiddeld aantal bits nodig om de uitgang van een discrete geheugenloze bron te coderen met een willekeurig kleine foutprobabiliteit naar onder begrensd is door de entropie H(X) van de bron. Anderzijds, indien R < H(X) zal de foutprobabiliteit 1 benaderen wanneer de bloklengte J toeneemt. De interpretatie van dit theorema is de volgende. De entropie v an de bron die blokken van J symbolen genereert is gegeven door JH(X), terwijl N de entropie is van een codewoord van N bits waarbij elk bit even waarschijnlijk en statistisch onafhankelijk is. De codewoorden, als alternatieve representatie van de typische blokken hebben dus dezelfde entropie als deze blokken. Volgens het theorema vermindert de entropie nagenoeg niet door het uitschakelen v an de niet-typische blokken. Alle typische blokken hebben nagenoeg dezelfde probabiliteit, zodat het niet te verwonderen is dat de codewoorden hun maximaal bereikbare entropie van 1 bit per letter hebben. De codeletters zijn dan alle even waarschijnlijk. De codeletters zijn ook statistisch onafhankelijk. 35

Tabel 3.1: Variabele- lengte codes Symbool P(ak) Code I Code II Code III a1 1/2 1 0 0 a2 1/4 00 10 01 a3 01 1/8 110 011 a4 1/8 10 111 111

3.4.2 Variabele-lengte codes Wanneer de bronsymbolen niet allemaal even waarschijnlijk zijn, is het efficiënter om de bronsymbolen te coderen in codewoorden met variabele lengte. Een voorbeeld van zo een code is de Morsecode. In Morsecode worden letters die veel voorkomen gecodeerd met een kort codewoord, terwijl letters die weinig voorkomen gecodeerd worden met langere codewoorden. Wanneer we dit principe doortrekken naar andere bronnen, betekent dit dat we de probabiliteit dat een bronsymbool optreedt kunnen gebruiken om codewoorden toe te kennen aan bronsymbolen. Deze manier van codering wordt entropiecodering genoemd. Bijvoorbeeld, stel dat we een discrete geheugenloze bron hebben met mogelijke uitgangen a 1 , a2 , a3 en a4 , met corresponderende probabiliteiten P(a i ) = 1/2, P(a 2 ) = 1/4 en P(a3 ) = P(a4 ) = 1/8. De uitgang van de bron wordt gecodeerd zoals getoond in tabel 3.1. Code I is een variabele lengte code die een fundamentele fout bevat. Om de fout te zien beschouwen we sequentie 001001.... Het is duidelijk dat het eerste symbool, corresponderend met 00 gegeven is door a 2 . Echter, de volgende vier bits zijn niet eenduidig te decoderen. Deze vier bits kunnen enerzijds als a 4a3 gedecodeerd worden of anderzijds als a 1 a2a1 . Het is mogelijk dat de dubbelzinnigheid over deze bits opgelost wordt wanneer we wachten op de volgende bits, maar zo een vertraging is in veel gevallen niet gewenst. Daarom beschouwen we in het vervolg enkel codes die ogenblikkelijk decodeerbaar zijn, d.w.z. zonder enige vertraging bij het decoderen. Code II in tabel 3.1 is uniek en ogenblikkelijk decodeerbaar. Men kan de codewoorden van code II eenvoudig voorstellen op een grafische manier als de takken van een boomstructuur, zoals getoond in figuur 3.1. We observeren dat de bit 0 het einde van een codewoord aangeeft voor de eerste drie symbolen. Deze eigenschap plus het feit dat geen v an de codewoorden langer is dan drie bits maakt de code ogenblikkelijk decodeerbaar. Merk op dat geen v an de codewoorden in deze code een prefix vormt van een ander codewoord. In het algemeen vereist de prefixvoorwaarde dat voor een gegeven codewoord Ck van lengte k met elementen (b 1 , b2 , ... , bk) er geen ander codewoord met lengte e < k bestaat met elementen (b 1 , b2, ... , be) voor 1 < e < k. Met andere woorden, er bestaat geen codewoord van lengte e < k dat gelijk is aan de eerste e bits van het codewoord met lengte k > e. Deze eigenschap zorgt ervoor dat de code ogenblikkelijk decodeerbaar is. Code III in tabel 3.1 heeft de boomstructuur getoond in figuur 3.2. Merk op dat deze code wel uniek maar niet ogenblikkelijk decodeerbaar is. Deze code voldoet duidelijk niet aan de prefixvoorwaarde. 36

Figuur 3.1; Codeboom voor code II in tabel 3.1 fa'

1

.a2

1

•

1

a3

1

1

• a4

Figuur 3.2: Codeboom voor code III in tabel 3.1 We willen nu een systematische procedure om een uniek decodeerbare variabele-lengte code te ontwerpen die efficiënt is in het opzicht dat het gemiddelde aantal bits per symbool, gedefi ieerd als (/ (3.13) R= nkPlk)

E k=1

geminimaliseerd wordt, waarbij nk de lengte is van het codewoord corresponderend met het symbool ak. De voorwaarden voor het bestaan van een code die voldoet aan de prefixvoorwaarde, worden gegeven door de Kraft-ongelijkheid. Kraft-ongelijkheid. Een nodige en voldoende voorwaarde voor het bestaan < nL die van een binaire code met codewoorden met lengte n 1 < n2 < ... _ voldoet aan de prefixvoorwaarde is gegeven door

E 2 -nk <

1.

(3.14)

k=1

Anderzijds, de lengtes nk van elke prefixcode voldoen aan (3.14). Eerst tonen we aan dat (3.14) een voldoende voorwaarde is voor het bestaan van een code die aan de prefixvoorwaarde voldoet. Neem een complete boom van de orde n = nL , die 2n eindknooppunten heeft. Elk knooppunt van orde k — 1 is verbonden met twee knooppunten van orde k, zoals getoond in figuur 3.3. Kies een willekeurig knooppunt van orde n 1 als het Bewijs:

37

eerste codewoord C 1 . Deze keuze elimineert 2n-n' eindknooppunten (of een fractie 2 - n' van de 2n eindknooppunten). Uit de overige knooppunten van orde n2 kiezen we willekeurig een knooppunt waaraan we het codewoord C2 toekennen. Deze keuze elimineert 2 n-n2 eindknooppunten (of een fractie 2 -n2 van de 2n eindknooppunten). Dit proces gaat door totdat het laatste codewoord wordt toegekend aan een eindknooppunt van orde n = nL . Aangezien, op een knooppunt van orde j, het aantal geëlimineerde eindknooppunten gegeven is door j

L

2-nk < > 2 -nk < 1, k=1

k=1

_

is er steeds een knooppunt van orde k > j beschikbaar om toegekend te worden aan het volgende codewoord. Op deze manier hebben we een codeboom geconstrueerd via een complete boom met 2n eindknooppunten, zoals getoond in figuur 3.3 voor een boom met 16 eindknooppunten en een bronuitgang bestaande uit 5 symbolen met n 1 = 1, n2 = 2, n3 = 3, en n4 = n5 = 4. Om te bewijzen dat (3.14) een nodige voorwaarde is, observeren we dat in de codeboom van de orde n = n L , het aantal geëlimineerde eindknooppunten (v an 2n beschikbare eindknooppunten), gegeven is door de 2n-nk < 2n r k=1

waaruit volgt dat 2 -nk < 1. k=1

0

Elke uniek decodeerbare code met lengtes n 1 , ... , nL voldoet aan de ongelijkheid van Kraft.Hieuvolgdzcstekanvrgwode nprfixc met dezelfde lengtes nk, k = 1, ... , L. De Kraft-ongelijkheid kan gebruikt worden om het volgende (verliesloos) broncoderingstheorema te bewijzen, dat toepasbaar is op codes die voldoen aan de prefixvoorwaarde. Elke discrete bron met entropie H(X) kan gecodeerd worden met een prefixcode, zodanig dat de gemiddelde lengte R van de codewoorden voldoet aan Broncoderingstheorema II:

H(X)

< R < H(X) + 1.

(3.15)

Bewijs: Om de ondergrens in (3.15) te bekomen merken we op dat voor codewoorden met lengte nk, 1 < k < L het verschil H (X) — R kan geschreven

38

C4 C5

Figuur 3.3: Constructie van een binaire boomcode via een complete boom worden als ( H(X) ` R =

1

L

pk

k=1

E pk log2 — k=1

pknk

2 -nk

L

= E pk loge k=1

Pk

Het gebruik van de ongelijkheid ln z < z - 1 geeft ons H(X)- ^ <

(log2 e)

= (log2 e)

E pk k=1

-

E 2 - nk - 1 k=1

39

( 2;: k

1^ < 0,

waarbij de laatste ongelijkheid volgt uit de Kraft-ongelijkheid. De gelijkheid geldt enkel indien pk = 2- nk voor 1 < k < L. De bovengrens in (3.15) kan bekomen worden, onder de voorwaarde dat nk , 1 < k < L gehele waarden zijn, door {nk} zo te selecteren dat 2-nk < pk < 2-nk+1 Indien de termen pk > 2 -nk gesommeerd worden over 1 < k < L, dan bekomen we de Kraft-ongelijkheid, waarvoor we aangetoond hebben dat er een code bestaat die voldoet aan de prefixvoorwaarde. Anderzijds, indien we het logaritme van pk < 2 -n k +1 nemen, d an bekomen we log e pk

< -nk + 1,

of nk

< 1 - log2 pk .

Indien we beide leden vermenigvuldigen met pk en sommeren over 1 < k < L, dan bekomen we de gewenste bovengrens in (3.15). Dit bewijst het tweede bronco deringstheorema. 0 We hebben hierboven aangetoond dat variabele-lengte codes, die voldoen aan de prefixvoorwaarde, efficiënte codes zijn om de uitgang van een discrete geheugenloze bron met niet even waarschijnlijke symbolen te coderen. We beschrijven nu een algoritme om zulke codes te construeren. Huffman stelde een algoritme voor gebaseerd op de probabiliteiten P(xi ), i = 1, ... , L van de symbolen. Met dit algoritme genereert men een variabele-lengte code dat optimaal is in de zin dat het gemiddeld aantal bits nodig om een bronsymbool voor te stellen minimaal is. Verder voldoen de codewoorden aan de prefixvoorwaarde, waardoor de code uniek en ogenblikkelijk decodeerbaar is. We illustreren het algoritme a an de hand van twee voorbeelden. Huffman codeeralgoritme:

Voorbeeld 1: Beschouw een discrete geheugenloze bron met zeven mogelijke uitkomsten x l , ... , x 7 , met probabiliteiten getoond in tabel 3.2. We hebben de > bronsymbolen geordend in dalende volgorde van waarschijnlijkheid, nl. P(x i ) _ P(x2) > ... > P(x7 ). We beginnen het codeerproces door de twee symbolen met de kleinste waarschijnlijkheid te nemen, nl. x 6 en x 7 . Deze twee symbolen worden samengenomen volgens figuur 3.4, waarbij de bovenste tak een 0 wordt toegewezen en de onderste tak een 1. De probabiliteiten van beide takken worden samengevoegd, zodat deze een totale probabiliteit heeft van 0.01. Nu hebben we de symbolen x 1 i x2 , ... , x5 en een nieuw symbool xs, ontstaan door het combineren van x6 en X7. Vervolgens combineren we opnieuw de twee minst waarschijnlijke symbolen uit de set x l , x2 , x3, x4 , x5 , x/6 . Dit zijn x5 en x6, met gezamenlijke probabiliteit 0.05. De tak corresponderend met x 5 wordt een 0 toegewezen, en de tak met x'6 een 1. Deze werkwijze wordt verder gevolgd tot alle mogelijke symbolen beschouwd zijn. Het resultaat is een codeboom,

40

Tabel 3.2: Een voorbeeld van een variabele-lengte code voor een discrete geheugenloze bron Symbool P(xi ) Eigeninformatie Codewoord 0.35 1.5146 xi 00 x2 0.30 1.7370 01 x3 0.20 2.3219 10 0.10 X4 3.3219 110 x5 0.04 4.6439 1110 xs 0.005 7.6439 11110 x7 0.005 7.6439 11111 H(X) = 2.11 R = 2.21 0

0.35

0.65 0

0.30 0.20 0.35

0.10 0.15

0.04 0.005 0.005

1

^0 0.01 1

0.05 1 1

Figuur 3.4: Een voorbeeld v an een variabele lengte code voor een discrete geheugenloze bron waarbij de takken de gewenste codewoorden vormen. De codewoorden worden gevormd door de codebits te combineren die men tegenkomt wanneer men de boom van rechts naar links doorloopt. De resulterende woorden worden getoond in tabel 3.2. Het gemiddeld aantal bits per symbool voor deze code is gelijk aan R = 2.21 bits/symbool (zie (3.13)). De entropie van de bron is H(X) = 2.11 bits/symbool. Merk op dat de geconstrueerde code niet noodzakelijk uniek is. Bijvoorbeeld, in de laatste stap van de codering hebben x 1 en x'3 dezelfde probabiliteit. Op dit punt kiezen we het paar x 1 en x2 . We hadden even goed het paar x 2 en x3 kunnen kiezen, met als resultaat de code getoond in figuur 3.5 en tabel 3.3. Het gemiddeld aantal bits per symbool voor deze code is ook 2.21. Beide codes zijn dus even efficiënt. Verder, de toekenning van de bit 0 aan de bovenste tak en de bit 1 aan de onderste tak is arbitrair. We kunnen dus de toekenning van 0 en 1 omkeren, en een efficiënte code bekomen die voldoet aan de prefix-voorwaarde. 41

0.35 0.30 0.65

0.20 0.10

1

0.15

0.04

1

0.05

0.005 0.005

1

0.35

1 1 1

Figux13.5: Alternatieve code

Tabel 3.3: Alternatieve code Symbool Codewoord xl 0 x2 10 x3 110 x4 1110 x5 11110 xs 111110 x7 111111

R = 2.21 Voorbeeld 2: We bepalen nu de Huffm an -code voor de uitgang van de discrete geheugenloze bron getoond in tabel 3.4. De entropie van deze bron is H(X) = 2.63 bits/symbool. De Huffman-code is getoond in figuur 3.6 en tabel 3.4, en heeft een gemiddelde lengte R = 2.70 bits/symbool. De efficiëntie van de code is 0.97.

3.4.3

Vectorcodering

Het variabele-lengte codeeralgoritme v an Huffman beschreven in de voorgaande sectie genereert een prefixcode met een gemiddelde lengte R die voldoet aan (3.13). Echter, in plaats van symbool per symbool te coderen, kan men op een efficiëntere wijze J symbolen tegelijk coderen. In dit geval herleiden de grenzen bepaald door het tweede broncoderingstheorema zich tot JH(X) < (3.16) < JH(X) + 1, aangezien de entropie van een blok van J symbolen afkomstig van een discreet geheugenloze bron JH(X) is en Rj is het gemiddeld aantal bits per blok van J symbolen. Indien we 42

Tabel 3.4: Huffmancode voor voorbeeld 2 Symbool P(x; ) Codewoord x1 0.36 00 0.14 010 x2 X3 011 0.13 0.12 100 X4 X5 0.10 101 0.09 110 X6 X7 0.04 1110 xs 0.02 1111 H(X) = 2.63 R = 2.70 0 0.63 0

0.36 0

0.14

0.27

0.13

1

0.12

0.22 0

0

0.10

1

0.09

0

0.37

0.15

0.04

0 0.06

0.02

1

Figuur 3.6: Huffmancode voor voorbeeld 2 (3.16) delen door J, dan bekomen we

H(X) < R < H(X) + ^ ,

(3.17)

waarbij R= Rj/J het aantal bits per symbool is. Hieruit volgt dat we R zo dichtbij als gewenst bij de entropie H(X) kunnen brengen door J voldoende groot te kiezen. Voorbeeld: Beschouw een discrete geheugenloze bron met mogelijke uitkomsten x1 , x2 , x3 , met respectievelijke probabiliteiten 0.45, 0.35 en 0.20. De entropie van deze bron is H(X) = 1.518 bits/symbool. De Huffman-code voor deze bron wordt gegeven in tabel 3.5. De code heeft R 1 = 1.55 bits/symbool nodig en heeft een efficiëntie van 97.9 %. Indien symboolparen gecodeerd worden met het Huffman-algoritme, dan bekomen we de code in tabel 3.6. De entropie van de uitgang van de bron voor symboolparen is 2H(X) =

43

Tabel 3.5: Huffman-code voor voorbeeld 3 symbool probabiliteit eigeninformatie codewoord 0.45 xi 1.156 1 x2 0.35 1.520 00 x3 0.20 2.330 01 H(X) = 1.518 bits bool Rl = 1.55 bits/symbool efficiëntie = 97.9 % Tabel 3.6: Huffman-code voor het coderen van symboolparen symbool probabiliteit eigeninformatie codewr xix1 xi xl 0.2025 2.312 10 xl x2 0.1575 2.676 001 x 2x 1 0.1575 2.676 010 x2x2 0.1225 3.039 011 xl x3 0.09 3.486 111 1 x3 0.09 3.486 0000 2x3x 0.07 3.850 0001 2 x3 0.07 3.850 1100 3x3x 0.04 4.660 1101 2H(X) = 3.036 bits/symboolpaar R2 = 3.0675 bits/symboolpaar R2 /2 = 1.534 bits/symbool efficiëntie = 99.0 % 3.036 bits/symboolpaar. De Huffman-code in dit geval heeft R2 = 3.0675 bits/symboolpaar nodig. Hieruit volgt dat de efficiëntie van de code stijgt tot 2H(X )/R2 = 0.990 of 99.0 %. Uit de voorbeelden volgt dat efficiënte codering van een discrete geheugenloze bron kan verwezenlijkt worden door symbool per symbool te coderen met een variabele-lengte code gebaseerd op het Huffman-algoritme. Verder, de efficiëntie van de codering k an opgedreven worden indien blokken van J symbolen tegelijkertijd worden gecodeerd. Hieruit volgt dat de uitgang van een discrete geheugenloze bron met entropie H(X) kan gecodeerd worden met behulp van een variabele-lengte code met een gemiddeld aantal bits per symbool dat de entropie H(X) zo dicht mogelijk benadert als gewenst is.

3.5 Codering voor discrete stationaire bronnen In de vorige sectie hebben we een efficiënt codeeralgoritme beschreven voor de uitgang van een discrete geheugenloze bron. In deze sectie beschouwen we discrete bronnen waarvoor de 44

opeenvolgende symbolen van de bron statistisch afhankelijk zijn van elkaar. We beperken ons tot bronnen waarvan de statistiek stationair is. Beschouwen we de entropie van een willekeurige sequentie van symbolen afkomstig van een stationaire bron. Uit de definitie in (2.16) en het resultaat in (2.17) vinden we dat de entropie van een vector van toevalsgrootheden gegeven is door k

(/

H(X1, X2,

X1 X2>... , Xi -1) HIXi I X1^X2>...,Xi-1)^ HIXi

=

|

^

(3.18)

^

i= 1

waarbij H(Xi H(Xi|I X1i X2 , ... , Xi_ 1 ) de conditionele entropie is van het ide symbool, gegeven de vorige i — 1 symbolen. De entropie per symbool voor een vector met k symbolen is gegeven door (3.19) Hk(X) = k H(X1, X2, ... , Xk). We definiëren de informatie-inhoud van een stationaire bron als de entropie per symbool, zoals gedefinieerd in (3.19), voor k —4 oo. Dit is (3.20) km Hk(X) = km k H(X1 i Xz ... Xk). Dat deze limiet bestaat wordt later bewezen. Alternatief kunnen we de entropie per symbool d n in termen van de conditionele k IX 1i X2 , ... , Xk_ 1 ) als k —> oo. Deze limiet bestaat eveneens, en is gelijk entropie H(X H(Xk|X1i aan de limiet in (3.20):

Hoo(X)

,

,

Hoo (X) = lim H(XkIX1> X2, ...,Xk -1)• k—> co

Bewijs: Eerst tonen we aan dat H(X k I X 1i

, Xk_1) C H(Xk-1I k-1|X1, . . . , Xk-2),

voor k > 2. Uit de eigenschappen van entropie volgt dat conditH(Xk|en op een toevalsgrootheid |X1 entropie niet kan verhogen. We vinden dus H(XkJ X1 ... , Xk-1)

< H(Xk! X2, . . . , Xk_ 1 ).

Uit de stationariteit van het kanaal volgt H(Xk I X2 i ... Xk_l) _ HH(Xk| 1X1 , Xk_2). Hieruit volgt (3.22). Dit resultaat toont aan dat de entropie H(Xk ^ X I ... , Xk_1) een niet-stijgende functie is van k. Ten tweede hebben we ,

,

Hk(X) > H(XkI X1 ... X ,

,

wat volgt uit (3.18) en (3.19H(Xk|X1>X2,...,Xk-1)• laatste term in (3.20) een 1 andere termen. ondergrensH(Xk|t voor elk van H(X 45

Ten derde, wegens de definitie van Hk (X) kunnen we schrijven dat 1

Hk(X)

X2, • • • , Xk-1) + H(Xk| Xl, • • • , Xk-1)]

_

= kRk — 1)Hk-1(X) +H(Xk|Xl,...,Xk-1)J k

1 Hk_1 + k Hk(X),

wat zich herleidt tot

Hk(X) < Hk-1(X), m.a.w. Hk (X) is een niet-stijgende functie van k. Aangezien Hk(X) en de conditionele entropie H(Xk|X 1i ... ,Xk _ 1 ) beide nietnegatieve en niet-stijgende functies zijn van k, moeten beide limieten bestaan. De limieten kunnen bekomen worden door gebruik te maken van (3.18) en (3.19) om Hk+á (X) neer te schrijven

Hk+á (X ) =

1 k+ jH(Xi,X2,..., Xk -1)

1

+k+j[H(Xk|Xl,...,Xk+k+ [H(XkIXl,...,Xk-1)+H(Xk )+H(Xk+1|X1,...,Xk) +1 1 X1, ...,Xk) 1

j + ... +H(Xk+j I Xl,...,Xk+j-1)i• z+...+H(Xk+j|Xl,...,Xk+j-1)i•

Aangezien de conditionele entropie niet toeneemt, kan de eerste term tussen de vierkante haken gebruikt worden als bovengrens voor de andere termen, m.a.w.

Hk+J (X) < k + j H(X 1 ,X2, ... , Xk _ 1) + k + . H(XkjX1, ... , H(X k|• Voor gegeven k, zal de limiet van de bovenstaande uitdrukking, als j -a oo gegeven zijn door

Hco(X) < H(XkI X1, ... , Echter, deze limiet is geldig voor alle waarden van k, dus ook voor k --* oo. Daarom geldt

Hoo(X ) < kk^^H (Xk|

Xk -1)•

Anderzijds, uit (3.23) volgt, wanneer we de limiet nemen voor k

H(XkIX1, ... • •,, Xk-1)• Hoo(X) > k ^m mooH(Xk|X1,• oo Uit de twee bovenstaande ongelijkheden volgt noodzakeli

46

oo, dat

Stel nu dat we een discrete stationaire bron hebben die J symbolen genereert met als entropie per symbool Hj(X). We kunnen de sequentie van J symbolen encoderen met het variabele-lengte Huffman codeeralgoritme, dat voldoet aan de prefixvoorwaarde, door de procedure te volgen die in de vorige sectie beschreven staat. De resulterende code heeft een gemiddelde codelengte (uitgedrukt in bits/symbool) voor de sequentie van lengte J dat voldoet aan de voorwaarde H(X 1 , ... , X.) < ui < H(X 1 ... X ^ ) + 1. ,

,

(3.24)

Door beide leden van (3.24) te delen door J bekomen we de grenzen voor het gemiddeld aantal bits per symbool R = Rj/J: H,(X) < R < H,(X) + 1/J.

(3.25)

Door de lengte J van de sequentie te laten toenemen, kan Hj (X) willekeurig dicht worden benaderd, en in de limiet voor J --> oo geldt voor R H„„(X) < R < H,(X) + e,

(3.26)

waarbij c naar nul gaat volgens 1/J. Dit betekent dat efficiënte codering van stationaire bronnen kan bekomen worden wanneer lange sequenties van bronsymbolen worden gecodeerd in codewoorden. Echter, er dient opgemerkt te worden dat het gebruik van het Huffman codeeralgoritme vereist dat de gezamenlijke distributie van de sequentie van lengte J gekend is.

3.6 Het Lempel-Ziv algoritme In sectie 3.4.2 hebben we gezien dat het Huffman codeeralgoritme optimaal is in de zin dat deze code voldoet aan de prefixvoorwaarde en de gemiddelde bloklengte van de code minimaal is. Om een Huffman code te ontwerpen voor een discrete geheugenloze bron, moeten we probabiliteit van elk bronsymbool kennen. En in het geval van een discrete bron met geheugen, moeten we de gezamenlijke probabiliteit kennen van blokken van symbolen van lengte n > 2. In de praktijk kennen we dikwijls de statistiek van de bron niet. In principe is het mogelijk de statistiek van de bron te schatten door gedurende lange tijd de uitgang van de bron te observeren en de probabiliteiten van de bronsymbolen empirisch te bepalen. Echter, behalve voor het bepalen van de marginale probabiliteiten {p k }, corresponderend met de kans dat een bepaald symbool voorkomt, is de complexiteit voor het bepalen van de gezamenlijke probabiliteiten zeer hoog. Daarom is het gebruik van het Huffman codeeralgoritme voor bronnen met geheugen niet praktisch. In tegenstelling tot het Huffman codeeralgoritme is het Lempel-Ziv codeeralgoritme onafhankelijk van de statistiek van de bron, m.a.w. het algoritme behoort tot de kl as se van universele broncodeeralgoritmes. Het Lempel-Ziv codeeralgoritme is een algoritme dat een sequentie bronsymbolen van een variabele lengte omzet in een codewoord met 47

vaste lengte. Om de bronuitgang te coderen maakt het Lempel-Ziv algoritme gebruik van woordenboeken. Bij codering met woordenboeken gaat de encoder de bronuitgang vergelijken met sequenties van symbolen die opgenomen zijn in een woordenboek. Indien een sequentie van symbolen voorkomt in het woordenboek, dan kan men de positie van deze sequentie in het woordenboek doorsturen in plaats van de sequentie zelf. Deze technieken maken gebruik van de correlatie tussen de bronsymbolen: hoe sterker de correlatie tussen de bronsymbolen is, des te langer de sequentie van symbolen is die men kan vervangen, en des te beter de compressie is (m.a.w. hoe lager het gemiddeld te versturen debiet R aan bits/symbool is). In de volgende paragrafen bespreken we enkele varianten van het Lempel-Ziv codeeralgoritme, nl. LZ77, LZ78 en LZW. Deze algoritmes worden gebruikt in compressie van tekst en in archiveringsprogramma's, zoals compress, pkzip, arj, gzip, PostScript Level 2 enz., in datatransmissie (in de V42bis standaard voor modems) en beeldcompressie (GIF en TIFF formaten). 3.6.1 Het LZ77 algoritme

Het LZ77 algoritme werd ontworpen door Lempel en Ziv in 1977. Het algoritme maakt gebruik van de herhaling van zinnen, woorden en delen van woorden, in zowel tekst als binaire data. Een eenvoudig voorbeeld v an een tekst kan zijn: 'The receiver requires a receipt which is automatically sent when it is received.'

Deze zin bevat verschillende herhalingen van de sequentie 'recei'. De herhalingen gaat men coderen en de andere woorden laat men ongecodeerd. Om de gecodeerde en ongecodeerde delen aan te duiden, gebruikt men vlaggen. We kunnen nu bijvoorbeeld de zin veranderen door de vlag #m#n te gebruiken, waarbij #m het aantal karakters is dat men moet teruggaan in de tekst om dezelfde sequentie van karakters te vinden, en #n het aantal karakters is dat vervangen wordt. De gecodeerde zin zou dus kunnen zijn: 'The receiver requires a #20#5pt which is automatically sent wh#6#2 it #30#2 #47#5ved.'

In het algemeen zal een lange sequentie of tekst veel herhalingen bevatten, zodat veel sequenties kunnen vervangen worden door vlaggen. Echter, merk op dat deze methode niet altijd zal leiden tot compressie, bijvoorbeeld in het geval waarbij korte sequenties vervangen worden door vlaggen die langer zijn dan de vervangen sequentie zelf. Om een sequentie te kunnen vervangen heeft het algoritme een woordenboek nodig. Bij het LZ77 algoritme bestaat het woordenboek uit een deel van de voorafgaande gecodeerde sequentie. De encoder codeert de sequentie met behulp van een schuivend venster. Het schuivend venster bestaat uit twee delen (figuur 3.7): een zoekbuffer, dat bestaat uit een 48

match pointer

a

x

x

a

b

P

a

a

d

a

zoekbuffer

^ ^

L

b

^ ^

L

p

^ ^

a

^ ^

p

LL

^ ^

L

p

^ ^

a

^ ^

LI

p

p a x

look-ahead buffer

Figuur 3.7: Het schuivend venster deel van de voorafgaande gecodeerde sequentie (typisch enkele duizenden symbolen), en een 'look-ahead' buffer, dat het volgende deel van de sequentie bevat dat gecodeerd moet worden (typisch tien tot honderd symbolen). Om de sequentie in de look-ahead buffer te encoderen, gebruikt de encoder een zoekpointer, die van rechts naar links de zoekbuffer afloopt totdat het een symbool tegenkomt dat overeenkomt met het eerste symbool in de look-ahead buffer. De afstand tussen tussen de zoekpointer en het eerste symbool in de look-ahead buffer noemt men de offset. De encoder bestudeert de symbolen die volgen op het symbool op de zoekpointer om te zien of deze overeenkomen met de opeenvolgende symbolen in de look-ahead buffer. Het a antal opeenvolgende symbolen in de zoekbuffer die overeenkomen met de opeenvolgende symbolen in de look-ahead buffer noemt men de lengte van overeenkomst. De encoder zoekt in de zoekbuffer totdat hij de grootste lengte van overeenkomst heeft gevonden. Wanneer de encoder de sequentie in de zoekbuffer heeft gevonden met de grootste lengte van overeenkomst, codeert de encoder de sequentie met deze lengte in de look-ahead buffer met behulp van het triplet < O, L, C >, waarbij 0 de offset, L de lengte van overeenkomst en C het codewoord is dat overeenkomt met het symbool in het look-ahead buffer dat volgt op de sequentie die net gecodeerd werd. Voorbeeld: We wensen de sequentie ... cabracadabrarrarrad...te coderen. We gebruiken een schuivend venster met lengte 13 en de lengte van het lookahead buffer is 6. In de eerste stap bevat de zoekbuffer de sequentie cabraca en de look-ahead buffer dabrar (figuur 3.8). Het eerste symbool in de look-ahead buffer is d. In de zoekbuffer is geen d aanwezig, dus coderen we dit eerste karakter met het triplet < 0, 0, d >. Het venster verschuift een symbool naar rechts. De zoekbuffer bevat nu de sequentie abracad, en de look-ahead buffer abrarr (figuur 3.9). In de tweede stap wordt de sequentie abra vervangen door het triplet < 7, 4, r >. Het venster verschuift 5 symbolen naar rechts. Het venster bevat nu de symbolen getoond in figuur 3.10. De encoder codeert de sequentie rarra met het triplet < 3, 5, d >. De encoder verstuurt de originele sequentie in de zoekbuffer (cabraca) en de verschillende triplets. Het decoderen v an de ontvangen sequentie gebeurt als volgt. De decoder neemt de originele sequentie cabraca van de zoekbuffer over. Uit het triplet < 0, 0, d> leidt de decoder af dat hij aan de huidige sequentie enkel een d moet toevoegen. 49

c

a

r

b

a

c

d

a

a

`

`

b

` r

Figuur 3.8: Coderen van de sequentie ...

^

a

^

r

^

r a r r a d

cabracadabrarrarrad ...:

stap 1

zoek pointer

c

a

0=7 b

r

a

d

c

i 1 1 1 1 1 a lb l r l a l r l ra LL LL LI

r r a

d

L=4 Figuur 3.9: Coderen van de sequentie ...

cabracadabrarrarrad ...:

stap 2

Het decoderen van het triplet < 7, 4, r > gebeurt zoals getoond in figuur 3.11: de decoder gaat 7 plaatsen terug in de sequentie en kopieert de 4 symbolen abra. Tenslotte voegt de decoder het symbool r aan de sequentie toe. Het triplet < 3, 5, d > wordt gedecodeerd als getoond in figuur 3.12. De decoder gaat 3 plaatsen terug in de sequentie. De decoder moet nu 5 symbolen kopiëren, maar er zijn maar 3 symbolen beschikbaar. De decoder kopieert dus eerste de 3 beschikbare symbolen rar. De volgende 2 symbolen zijn een kopie van de 2 eerste symbolen van de net gekopieerde sequentie. Tenslotte voegt de decoder het symbool d toe aan de sequentie. In het voorbeeld gebruikt het codeeralgoritme slechts een klein schuivend venster. Dit zorgt voor de volgende problemen: • De encoder gooit constant bruikbare sequenties weg, omdat ze uit het venster schuiven. • De beperkte lengte van het look-ahead buffer beperkt de lengte van de sequentie die we kunnen vervangen. zoek pointer a

d

a

b

1<

O=3

r

a

r

I

I

LL

I

I

LL

1 rIal I d

I

LI

I

> L=5

Figuur 3.10: Coderen van de sequentie ... 50

cabracadabrarrarrad ...:

stap 3

i a

ga 7 plaatsen terug b

r

a

c

a

d

a

d

kopieer 4 symbolen <

a

>

b

r

a

c

a

b

r

a

voeg r toe a

b

r

a

c

a

d

a

b

r

a

r

Figuur 3.11: Decoderen van het triplet < 7, 4, r >

ga 3 plaatsen terug r

a

c

a

d

a

b

r

a

r

kopieer 3 symbolen r

a

c

a

d

a

b

r

a

r

r

a

r

kopieer 2 symbolen F---> r

a

c

a

d

a

b

r

a

r

r

a

r

r

a

voeg d toe r

a

c

a

d

a

b

r

a

r

r

a

r

Figuur 3.12: Decoderen van het triplet < 3, 5, d >

51

r

a

• Het slechtste scenario dat we kunnen bekomen is dat we een sequentie hebben die periodisch is met een periode groter dan de lengte van de zoekbuffer. Om deze problemen op te lossen kan men de lengte van het schuivend venster vergroten. In dit geval zal men een sterkere compressie bekomen, maar de benodigde rekentijd zal sterk toenemen. Met het LZ77 algoritme k an men een sterke compressie bekomen voor verschillende types data. Het nadeel v an het LZ77 algoritme is dat het encoderen veel tijd in beslag neemt, aangezien er veel vergelijkingen moeten worden uitgevoerd tussen de look-ahead buffer en de zoekbuffer. Het decoderen echter is zeer eenvoudig en kan zeer snel uitgevoerd worden. Het algoritme heeft slechts weinig geheugen nodig, zowel voor het encoderen als het decoderen, aangezien enkel het schuivend venster moet worden opgeslagen in het geheugen. De grootte v an dit venster is typisch tussen 4 en 64 kbytes. Men kan aantonen dat het LZ77 algoritme as ymptotisch optimaal is: indien de te coderen sequentie lang genoeg is en de lengte van het schuivend venster naar oneindig gaat, zal het gemiddelde debiet de entropie willekeurig dicht benaderen. Echter, het probleem is dat de sequentie wel héél lang moet zijn vooraleer de entropie benaderd wordt.

3.6.2 Het LZ78 algoritme Een variant op het LZ77 algoritme werd voorgesteld door Lempel en Ziv in 1978. In plaats van een schuivend venster te gebruiken waarin de voorafgaande symbolen worden bijgehouden, maken encoders geb as eerd op het LZ78 principe gebruik van een woordenboek dat op een dynamische manier wordt opgebouwd. Het woordenboek is een geïndiceerde lijst die bestaat uit fr as en die voorkomen in de sequentie van bronsymbolen. Indien de encoder een fr as e (= bepaalde sequentie van symbolen) tegenkomt die reeds in het woordenboek is opgenomen, dan kan de index v an de fr as e in het woordenboek doorgestuurd worden in plaats van de frase zelf. Tegelijkertijd bouwt de encoder het woordenboek op. Dit gebeurt als volgt. De encoder verstuurt een sequentie van paren, waarbij een paar gegeven is door < P, C >: Pis de index van de fr ase in het woordenboek die de grootste overeenkomst heeft met de te coderen sequentie, en C is de code voor het symbool dat volgt op de sequentie die teruggevonden werd in het woordenboek. Dit paar < P, C > wordt nu opgenomen in het woordenboek als de nieuwste fras e. Dit betekent dat elke nieuwe fr as e in het woordenboek bestaat uit een bestaande fr as e uitgebreid met een nieuw symbool. In het begin van het coderen is het woordenboek leeg. Aangezien bij het coderen v an hetrsymbolgnvekmstiqunhewordbkanzigs, codeert men dit eerste symbool met de prefix P = 0. Ook indien een symbool nog niet voorkomt in het woordenboek is P = 0. Vooraleer men kan decoderen, moet het woordenboek gekend zijn. Het woordenboek moet dus eerst naar de ontvanger worden verstuurd (bij datatransmissie) of opgeslagen (indien de data wordt opgeslagen). 52

Tabel 3.7: Het LZ78 algoritme: Encodering en decodering Encoderen Woordenboek Uitgang encoder Index Inhoud <0,w> 1 w <0,a> 2 a 3 b <3,2> 4 ba < 0,k> 5 k <1,2> 6 wa < 3, 3 > 7 bb < 2, 5 > 8 ak < 6,3 > 9 wab <4,5> 10 bak < 9, 3 > 11 wabb <8,1> 12 akw o 13 < 13,5 > 14 ok <1,13> wo 15 < 14,1 > okw 16 < 13,13 > 17 00 <0, EOF> 18

Decoderen Ingang decoder <0,w> <0,a>

Uitgang decoder w a

< 3,2> < 0,k>

b ba k

<1,2> < 3,3 > < 2, 5 > < 6,3 > < 4,5> < 9,3 > <8,1>

wa

bb ak wab

bak wabb akw

<0,o> < 13,5 >

o ok

<1,13> < 14,1 > < 13,13 > <0, EOF>

okw o0

wo

Voorbeeld: Als voorbeeld beschouwen we de encodering en decodering van de sequentie wabbakwabbakwabbakwabbakwookwookwoo. De eerste drie uitgangen van de encoder zijn < 0, w >, < 0, a > en < 0, b >, die het initiële woordenboek vormen. De opbouw van het woordenboek en de verstuurde paren zijn gegeven in tabel 3.7. Het decodeerproces is eveneens opgenomen in tabel 3.7. Het grote voordeel van het LZ78 algoritme in vergelijking met het LZ77 algoritme is het verminderd aantal vergelijkingen tussen de sequenties in het woordenboek en de te coderen sequentie. Het LZ78 algoritme zal dus een sequentie sneller encoderen dan het LZ77 algoritme. De compressie die men bekomt met het LZ78 algoritme is vergelijkbaar met de compressie bij het LZ77 algoritme.

3.6.3 Het LZW algoritme In 1984 stelde Welch een vari ant voor op het LZ78 algoritme. Deze vari ant van het Lempel-Ziv algoritme wordt het meest gebruikt. Dit algoritme kan bijna alle soorten data comprimeren. In het LZW algoritme is het niet meer noodzakelijk het opgebouwde woordenboek te bewaren om de data te decoderen: het woordenboek kan opnieuw worden 53

Tabel 3.8: Het LZW algoritme: initialisatie van het woordenboek Index Inhoud 1 2 3 4 5

a b k 0

w

opgebouwd tijdens de decodering. Dit bespaart heel wat ruimte wanneer de data opgeslagen wordt. Het grote verschil tussen het LZ78 algoritme en het LZW algoritme is dat het woordenboek bij het begin van encodering niet leeg is: het LZW algoritme initialiseert het woordenboek met alle mogelijke symbolen van het bronalfabet (typisch wordt het woordenboek geïnitialiseerd met de 256 symbolen v an het ASCII alfabet). De uitgang van de encoder bestaat uit de index < P > van de frase in het woordenboek die overeenkomt met de te coderen sequentie. Indien de frase p opgenomen is in het woordenboek, en deze fr as e in de te coderen sequentie gevolgd wordt door het symbool a, dan wordt de fr as e pa opgenomen in het woordenboek, en de index corresponderend met de fr as e p wordt verstuurd. Daarna wordt de nieuwe sequentie, die begint met het symbool a gecodeerd. Voorbeeld: Als voorbeeld beschouwen we opnieuw de encodering en decodering van de sequentie wabbakwabbakwabbakwabbakwookwookwoo. Het woordenboek bevat initieel de verschillende symbolen in de sequentie, zoals getoond in tabel 3.8. Het woordenboek wordt opgebouwd zoals getoond in tabel 3.9, en de uitgang van de encoder is gegeven door de sequentie 5 1 2 2 1 3 6 8 10 12 9 117165441121234. Het decoderen begint met het initialiseren van het woordenboek, zoals getoond in tabel 3.8. De decoder bouwt het woordenboek op tijdens het decoderen, zoals getoond in tabel 3.10. Stel dat we elk symbool in de bronsequentie voorstellen met ASCII code (8 bits per symbool), en de index van het woordenboek voorstellen met 5 bits (32 mogelijke posities in het woordenboek), dan bestaat de originele sequentie uit 35x8 bits = 280 bits, terwijl de gecodeerde sequentie bestaat uit slechts 21x6 bits = 126 bits. We hebben de sequentie dus kunnen comprimeren tot 45% van de originele grootte.

Hoe selecteren we de grootte van het woordenboek in de LZ78 en de LZW algoritmes, m.a.w. hoeveel indices laten we toe? In het algemeen geldt dat hoe groot we het woordenboek ook kiezen, het woordenboek over zal lopen: er zullen teveel mogelijke fr as en optreden. Om dit overloopprobleem op te lossen, moeten de encoder en de decoder op dezelfde m an ier fr asen uit het woordenboek verwijderen, namelijk die fr as en die niet bruikbaar zijn 54

Tabel 3.9: Het LZW algoritme: opbouwen van het woordenboek en encodering Woordenboek Index Inhoud Uitgang encoder 1 a 2 b 3 k 4 0 5 w 6 wa 5 7 ab 1 8 bb 2 9 ba 2 10 ak 1 11 kw 3 12 wab 6 13 bba 8 14 akw 10 15 wabb 12 16 bak 9 17 kwa 11 18 abb 7 19 bakw 16 wo 20 5 21 00 4 22 ok 4 kwo 23 11 24 ook 21 25 kwoo 23 4 en de plaatsen in het woordenboek die hierdoor vrij komen kunnen dan hergebruikt worden voor andere fr as en. Er bestaan verschillende manieren om frasen uit het woordenboek te verwijderen: • Verwijder het volledige woordenboek wanneer de grootte van het woordenboek een bepaalde limiet overschrijdt. Deze methode wordt o.a. gebruikt bij GIF. • Verwijder het volledige woordenboek wanneer deze niet langer de sequentie effectief comprimeert, zoals o.a. gedaan wordt bij UNIX compress. • Verwijder de minst gebruikte frasen in het woordenboek wanneer de grootte van het woordenboek een bepaalde limiet overschrijdt, zoals in de Britisch Telecom standaard. 55

Tabel 3.10: Het LWZ algoritme: heropbouwen van het woordenboek en decodering Woordenboek Ingang decoder Uitgang decoder Index Inhoud 1 a 2 b 3 k 4 0 5 w 5 1 2 2

1 3

6 8 10 12 9 11 7 16 5 4 4 11 21 23 4

w

a b b a k wa bb ak wab ba kw ab bak w o o kw 00

kwo o

6

wa

7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

ab bb ba ak kw wab bba akw wabb bak kwa abb bakw

wo 00

ok kwo ook kwoo

Er bestaan verschillende variaties op het LZW algoritme, die de efficiëntie voor bepaalde toepassingen verbeteren. Een veelgebruikte aanpassing is dat de index varieert in lengte. Meestal begint men met 9 bits voor de index en laat men de lengte toenemen tot 12 of 13 bits. Wanneer de index een bepaalde waarde overschrijdt, die niet meer aangeduid kan worden met de gebruikte lengte, voegt men een bit toe zodat het aantal mogelijke indices verdubbelt. Voor het Lempel-Ziv algoritme geldt in het algemeen dat bestanden met statistisch onafhankelijk data, zoals uitvoerbare programma's of object code bestanden, typisch slecht kunnen gecomprimeerd worden (typisch is de grootte van het gecomprimeerde bestand 50 tot 95% van de originele grootte van het bestand), terwijl (bewegende) beelden, die veel herhalingen bevatten, zeer sterk kunnen gecomprimeerd worden (typisch is de grootte van 56

het gecomprimeerde bestand 2 tot 20% van de originele grootte van het bestand).

3.7 Quantisatie van analoge bronnen Om de uitgang van een analoge bron te kunnen coderen, zal men eerst de amplitude van de uitgang quantiseren en daarna kan men de gequantiseerde amplitudes coderen zoals de uitgang van een discrete bron. Quantisatie van de amplitudes van de uitgangen van een bron leidt niet enkel tot compressie van de data, maar introduceert ook een hoeveelheid distorsie. In deze sectie beschouwen we de minimalisatie van deze distorsie. 3.7.1 Optimale quantisatie We beschouwen eerst de distorsie door quantisatie in het geval waarbij een vast aantal bits gebruikt wordt om de analoge symbolen van de bron te quantiseren. Met distorsie bedoelen we een maat voor het verschil tussen de werkelijke symbolen {x k } en de gequantiseerde waarden {i k }, en we noteren deze distorsie als d(xk, ik ). Bijvoorbeeld, een veelgebruikte distorsiemaat is kwadratische-fout distorsie: (Xk — xk

dlxk

)2

die gebruikt wordt in puls-code modulatie. Andere distorsiematen kunnen algemeen geschreven worden als d(xk,xk) = |xk — xkV waarbij p een positief geheel getal is. Indien d(xk, xk) de distorsie per symbool voorstelt, dan kan men de distorsie tussen een sequentie van n waarden X n en de corresponderende n gequantiseerde waarden Xn schrijven als de gemiddelde over de n symbolen: 1n

d(Xn, Xn) = n E d(xk, ik) k=1

Aangezien de symbolen afkomstig zijn van een toevalsproces, zijn de n waarden X n toevalsgrootheden. Hieruit volgt dat d(X n , Xn ) ook een toevalsgrootheid is. De gemiddelde waarde van deze toevalsgrootheid noemen we de distorsie D n

D = E[d(Xn, Xn)] = n ^ E[d(xk, ik )] = E[d(x, x)] k =1

(3.27)

waarbij in de laatste stap verondersteld wordt dat de bron stationair is. Stel nu dat we een geheugenloze bron hebben met een analoge uitgang X waarvan de amplitude een distributie p(x) heeft. Verder veronderstellen we dat de gequantiseerde 57

versie van X een alfabet k heeft, en dat de distorsiemaat per symbool gegeven is door d(x, i), waarbij x E X en i E X. In dit geval is het minimale debiet dat nodig is om de uitgang X van de bron voor te stellen met een distorsie die kleiner is dan D gegeven door de rate-distortion functie R(D) min

R(D) =

p(iIx):E[d(X,X))
I(X; X)

(3.28)

waarbij I(X; k) de mutuele informatie is tussen X en X. In het algemeen zal het debiet R(D) toenemen wanneer D afneemt, en vice versa. Een speciaal geval van een analoge geheugenloze bron is het Gaussiaans bronmodel. Voor een gemiddelde kwadratische distorsiemaat kan men het minimale debiet per symbool nodig om de uitgang van de analoge geheugenloze Gaussiaanse bron voor te stellen bepalen als volgt. Om de rate te vinden moeten we I(X, X) minimaliseren onder de voorwaarde dat de gemiddelde distorsie kleiner of gelijk aan D moet zijn. Men kan bewijzen dat de rate een niet-stijgende functie is van de distorsie, m.a.w. de minimale rate treedt op wanneer de gemiddelde distorsie gelijk is aan D. oo D= d(x, i)p(x, )dxdi

^

^^

Een andere voorwaarde die we kunnen opleggen is dat de distributie p(i|x) genormeerd is:

f

+oo

p(ilx)di = 1 c.

We passen het Lagrangeformalisme toe op dit minimalisatieprobleem met randvoorwaard en, m.a.w. we minimaliseren +^

f

^

J%+ -^ 00

[îx , x) loge

P(

x) )p(

^

)

+ µd(x i)p(x, i) + v(x)p(x, i) dxdi ,

Leiden we het integrandum af naar p(x, i), dan bekomen we een oplossing van de vorm p(x|i) = B(x)e -ad(x 4) waarbij A bepaald wordt door de distorsie D en B(x) gekozen wordt zodat aan de volgende randvoorwaarde voldaan is: f +00 r +0 B(x)e- ^`d(x,x)dx p(x|i)dx = 1 = J 00 J Voor de analoge geheugenloze Gaussiaanse bron betekent dit dat B(x) een constante moet zijn. Na uitwerking vinden we de volgende rate: log2(O /D) 0 < DZ cq D > vx 0 .

R2(D) =

58

(3.29)

2— 1.8 -

Rg (D) bits/symbool

1.6 • 1.4 • 1.2 • 1 • 0.8 • 0.6 • 0.4 • 0.2 • 0 0

0.2

0.4

0.6

0.8

1

D/qcZ

Figuur 3.13: Rate-distortion functie voor een analoge geheugenloze Gaussiaanse bron waarbij al de variantie is van de uitgang van de Gaussiaanse bron. Merk op dat (3.29) nul wordt als D > cr (de rate kan niet negatief worden). Dit impliceert dat er geen informatie moet verstuurd worden indien D > 4. In het geval D = a! kan men de uitgang van de bron reconstrueren door allemaal nullen te gebruiken. In het geval D > o kunnen we de uitgang van de bron reconstrueren door statistisch onafhankelijke Gaussiaanse ruiswaarden met variantie D — uu te gebruiken. R9 (D) wordt getoond in figuur 3.13. De rate-distortion functie R(D) van een bron is gerelateerd met het volgende broncoderingstheorema. Theorema: Broncodering met een distorsiemaat. Er bestaat een codeerschema dat de uitgang van de bron afbeeldt op codewoorden zodat voor een gegeven distorsie D, het minimale debiet R(D) voldoende is om de uitgang van de bron te reconstrueren met een gemiddelde distorsie die willekeurig dicht bij D ligt.

Dit betekent dat de rate-distortion functie R(D) een benedengrens is voor het debiet bij een gegeven distorsie. We passen nu dit theorema toe op de geheugenloze Gaussiaanse bron. Drukken we D uit als functie van R9 (D), dan vinden we D9 ( R )

= 2-2R4 59

(3.30)

Deze functie noemen we de distortion-rate functie voor de geheugenloze Gaussiaanse bron. Drukken we (3.30) uit in dB, dan vinden we 10log 10 D9 (R) = —6R + 10 log io ay Merk op dat de gemiddelde kwadratische distorsie afneemt met 6 dB/bit. Voor andere, niet-Gaussiaanse bronnen is het soms zeer moeilijk de rate-distortion functie te bepalen. Echter, er bestaan boven- en ondergrenzen voor de rate-distortion functie voor een willekeurige analoge geheugenloze bron. Een bovengrens voor de ratedistortion functie van een analoge geheugenloze bron met gemiddelde nul en variantie ax is gegeven door 0 < D < a^ (3.31) R(D) < 2 log2 (ax2 /D) Dit betekent dat de Gaussiaanse bron het grootste debiet nodig heeft voor een gegeven distorsie, in vergelijking met alle an dere bronnen. Hieruit volgt dat voor om het even welke analoge geheugenloze bron met gemiddelde nul en variantie a! geldt dat R(D) < R9 (D). Voor de distortion-rate functie vinden we een zeer gelijkaardige bovengrens D(R) < D9 (R) = 2-2R a!

(3.32)

Er bestaat ook een ondergrens voor de rate-distortion functie. Deze ondergrens wordt de ondergrens van Sh an non genoemd voor een gemiddelde kwadratische distorsiemaat, en is gegeven door R*(D) = H(X) — 2 loge 27reD (3.33) waarbij H(X) de differentiële entropie is van de analoge geheugenloze bron. De distortionrate functie die met (3.33) overeenstemt is 1 2-2[R-H(X)] (3.34) 2 We vinden dus dat de rate-distortion functie voor een analoge geheugenloze bron begrensd is door (3.35) R* (D) < R(D) < R9(D) en de corresponderende distortion-rate functie door

D*(R)

D*(R) < D(R) < D9(R)

(3.36)

De differentiële entropie van, een geheugenloze Gaussiaanse bron is H9 (X) = 2 loge 27reax

zodat de ondergrens in (3.35) samenvalt met de bovengrens (R*(D) = R9 (D)). Drukken we nu D*(R) uit in dB en normaliseren we de uitdrukking door al = 1 te stellen, d an vinden we 101og10 D*(R) = —6R — 6[H9 (X) — H(X)] 60

Tabel

3.11: Differentiële entropie en rate-distortion functie voor verschillende distributies II (X)

p(x)

Gaussiaans Uniform Laplace Gamma Exponentieel

1

-2

2fo: > |x| C

v v

x

e—

=

f^ e 2ox -

V87rox Ix I

0 0.255

0 1.53

0.104

0.62

0.709

4.25

0.604

3.62

log2 (27reox) 2 1og2(2 v 3vx ) 1og2 (2e2Qx ) / 7e 0.423 0-x2 ) o g

_^^

!t/

D9 (R)—D*(R)

(dB)

sl

1 27ror

i

R9 (D)—R*(D) bits /symbool

2 l g2 l

log2 (ecrx )

-L e - '=,x> 0

of 101og10 , D9

^R^

6[H9 (X) — H(X)] dB = 6[R9 (D) — R*(D)] dB

Deze vergelijkingen laten ons toe de onder- en bovengrens van de distorsie te vergelijken. Merk op dat ook D*(X) afneemt met 6 dB/bit. Ook de differentiële entropie H(X) is naar boven begrensd door H9 (X). In tabel 3.11 wordt de differentële entropie en de ratedistortion functie getoond voor verschillende distributies.

3.7.2 Scalaire quantisatie In broncodering kan de quantisator geoptimaliseerd worden indien we de distributie van de signaalamplitude aan de ingang van de quantisator kennen. Bijvoorbeeld, stel dat de sequentie {x„} aan de ingang v an de quantisator een distributie p(x) heeft en dat het aantal quantisatieniveaus gelijk is aan L = 2R. We willen nu de optimale quantisator bepalen die een gegeven functie van de quantisatiefout q = — x minimaliseert, waarbij de gequantiseerde waarde is van x. Stel dat f (x — x) de gewenste functie is van de quantisatiefout. Dan is de distorsie veroorzaakt door de quantisatie van de amplitude f+^

D=J

f(x — x)p(x)dx

(3.37)

00

We noemen de quantisator optimaal indien D minimaal is. Dit kan door het optimaal kiezen van de quantisatieparameters: die quantisatieniveaus en het bereik van de amplitude van het ingangssignaal v an de quantisator dat op een bepaald quantisatieniveau afgebeeld wordt. De resulterende quantisator wordt de Max-Lloyd quantisator genoemd. Eerst beschouwen we echter het eenvoudige geval v an een uniforme quantisator.

61

Tabel 3.12: Optimale stapgrootte voor uniforme quantisatie van een Gaussiaanse toevalsgrootheid L Drain ©apt min 10 log Dmin (dB) 2 1.596 0.3634 -4.4 4 0.9957 0.1188 -9.25 8 0.5860 0.03744 -14.27 16 0.3352 0.01154 -19.38 32 0.1881 0.00349 -24.57 D

Uniforme quantisator In het geval van een uniforme quantisator (figuur 3.14) zijn de quantisatieniveaus I k = 2(2k — 1)O , waarbij het k-de quantisatieniveau gekozen wordt indien de amplitude v an x in het bereik (k — 1)0 < x < kO ligt, waarbij 0 de grootte van de quantisatiestap is. Indien zowel de uniforme quantisator als de distributie van de amplitude van de bron symmetrisch zijn rond het nulpint (f (x) = f (—x) en p(x) = p(—x)) en de quantisator een even aantal niveaus L heeft, dan wordt de gemiddelde distorsie

E f k0

L/2

D = 2

-1

k-1)p

k=1

f ( 1 (2k — 1)A — x)p(x)dx 2

t o0

+2

J (L/2-1)0

f(1 ( L — 1)0 — x)p(x)dx 2

De gemiddelde distorsie D is een functie van de stap A. We zoeken nu de waarde v an A die de distorsie minimaliseert. Leiden we D af naar A, dan vinden we

L/2-1

kA (2k — 1)

k=1 +(L — 1)

f-1-(

fk-1)p

1,

f'((2k — 1)0 — x)p(x)dx

2

f'( 1 (L — 1)0 — x)p(x)dx = 0 /2-1)^

2

waarbij f'(x) de afgeleide is van f (x). Wanneer men een foutcriterium f (x) vooropstelt, kan men de optimale grootte v an de stap numeriek bepalen voor elke distributie p(x). In tabel 3.12 wordt voor het gemiddelde kwadratische foutcriterium (f (x) = x2 ) de optimale stapgrootte en de gemiddelde kwadratische fout gegeven voor een Gaussiaanse distributie met gemiddelde nul en variantie 1. Merk op dat de gemiddelde kwadratische fout Dmin ongeveer 5 dB afneemt wanneer het aantal niveaus L verdubbelt. Hieruit volgt dat voor elk extra bit dat gebruikt wordt uniforme quantisatie van een Gaussiaans-verdeelde amplitude met optimale stapgrootte Dopt, de distorsie afneemt met ongeveer 5 dB. 62

40

*wag gastcueuXp

Figuur 3 .14 : Uniformequantisator

$q(X)

3A

I -4A -3A -2A -0^

r

0 A 2A 3A 4A -A -2A -3A -4A

L oneven

L even

Het dynamisch bereik van de uniforme quantisator wordt bepaald door de maximale waarde van de uitgang van de quantisator. Dit dynamisch bereik hangt af van de stapgrootte en het aantal niveaus (zie figuur 3.14). In het geval van een uniforme quantisator en een even aantal niveaus is het dynamisch bereik gegeven door het interval L2-1A, [-- L2-16,1. Niet- uniforme quantisator (Max-Lloyd)

Wanneer men de voorwaarde dat de quantisator uniform moet zijn laat vallen, k an men de distorsie nog kleiner maken. In dit geval kiezen we het quantisatieniveau x = ik indien xk_1 < x < xk . Stel dat er L niveaus zijn, dan zijn de r an dvoorwaarden x0 = —oo en xL = +oo. De resulterende distorsie is dan L

Xk

D=EJ k.1

f(xk

—

x)p(x)dx

(3.38)

Xk 1

De distorsie wordt nu geminimaliseerd door {xk} en {xk} optimaal te kiezen. Om de minimale distorsie te vinden, moeten we (3.38) afleiden naar {x k } en { xk}. Het resultaat van deze afleiding is

f

(

xk — xk)

f(xk +1 —

xk),

k = 1,2,...,L — 1

(3.39)

k = 1, 2, ..., L

(3.40)

2k

f'(x k — x)p(x)dx = 0, Lk-1

We beschouwen nu het speciale geval dat f (x) = x 2 , m.a.w. we minimaliseren de gemiddelde kwadratische fout. In dit geval wordt (3.39) k = 1,2,...,L -1

Xk = 2 (xk + xk +1 )1

wat het gemiddelde is van xk en xk+1. De vergelijkingen die 2k bepalen zijn ^

k

(x k — x)p(x)dx = 0, fsk

k = 1,2,..., L

-1

M.a.w. X- k is het zwaartepunt van p(x) in het interval [xk _ 1i xk]. Deze vergelijkingen kunnen op een numerieke manier opgelost worden voor elke distributie p(x). In tabellen 3.13 en 3.14 wordt de optimale Max-Lloyd quantisator gegeven voor een Gaussiaans verdeelde amplitude met gemiddelde nul en variantie 1, voor L = 4 en L = 8. In tabel 3.15 vergelijken we de gemiddelde kwadratische fout voor uniforme en niet-uniforme quantisatie. We merken dat het verschil tussen de twee types quantisatoren vrij klein is voor kleine waarden van R (minder d an 0.5 dB voor R < 3). Het verschil neemt toe wanneer R toeneemt. Bijvoorbeeld, voor R = 5 is de niet-uniforme quantisator ongeveer 1.5 dB beter dan de uniforme quantisator. 64

Tabel 3.13: Optimale quantisatie voor een Gaussiaanse toevalsgrootheid, L = 4

k 1 2 3 4

xk

Xk

-0.9816 0 0.9816 00 Dmin = 0.1175 10 log Dram = —9

-1.510 -0.4528 0.4528 1.510

Tabel 3.14: Optimale quantisatie voor een Gaussiaanse toevalsgrootheid, L = 8

k 1 2 3 4 5 6 7 8

Xk

xk

-1.748 -1.050 -0.5006 0 0.5006 1.050 1.748 00 Drain Dmin = 0.03454 10 lDmm Dmin rain = —14.62 dB

-2.152 -1.344 -0.7560 -0.2451 0.2451 0.7560 1.344 2.152

Tabel 3.15: Vergelijking tussen optimale uniforme en niet-uniforme quantisator voor een Gaussiaanse toevalsgrootheid Uniform R Niet -uniform (bits /symbool) 10log 10 D min (dB) 10 log10 Dmin (dB)

1 2 3 4 5 6 7

-4.4 -9.25 -14.27 -19.38 -24.57 -29.83 -35.13

65

-4.4 -9.3 -14.62 -20.22 -26.02 -31.89 -37.81

optimale uniforme quantisator

-1 0

on -15

entropie codering

optimale _ 1 niet-uniforme quantisator

-20 \\

distortion-rate fimctie voor een Gafunctiese bron

-25

,\

■

D(R)=2-2R

-30 0

1

2

3

4

5

R =log2L bits/symbool

Figuur 3.15: Distorsie versus debiet voor een geheugenloze Gaussiaanse bron In figuur 3.15 zetten we de minimale distorsie uit als functie v an het debiet R = log2 L (aantal bits per symbool), voor de uniforme en de niet-uniforme quantisator. Merk op dat de niet-uniforme quantisator een kleiner debiet R nodig heeft dan de uniforme quantisator voor dezelfde distorsie. De quantisator zet een bron met een continue amplitude om in een bron met een discrete amplitude X = {± k ,1 < k < L}, met probabiliteiten {pk}. Indien de continue amplitudes van het oorspronkelijke signaal statistisch onafhankelijk zijn, dan is de corresponderende

66

Tabel 3.16: Entropie voor de uitgang v an de optimale niet-uniforme quantisator voor een Gaussiaanse bron R Entropie Distorsie (bits /symbool) (bits/symbool) 10 log10 Dmin 1 1.0 -4.4 2 1.911 -9.30 3 2.825 -14.62 4 3.765 -20.22 4.730 -26.02 discrete bron geheugenloos. De entropie van deze discrete bron is dan H(X) = — Epklog2 pk k=1

Bijvoorbeeld, de optimale nietprobabiliteitensator met 4 niveaus voor de Gaussiaanse bron heeft probabiliteiten Pi = p 4 = 0.1635 voor de twee buitenste niveaus en probabiliteiten p2 = p3 = 0.3365 voor de twee binnenste niveaus. De entropie v an de discrete bron is H(X) = 1.911 bits/symbool. Passen we entropiecodering (Huffman-codering) toe op deze discrete bron, d an kunnen we een minimale distorsie v an -9.30 dB halen bij een debiet R = 1.911 bits/symbool in plaats van met 2 bits/symbool. In tabel 3.16 wordt de entropie gegeven voor de niet-uniforme quantisator. Deze waarden zijn ook weergegeven in figuur 3.15 met de vermelding 'entropie codering'. We besluiten dat de quantisator geoptimaliseerd kan worden indien de distributie van de continue amplitude van de uitgang van de bron gekend is. De optimale quantisator met L = 2R niveaus heeft een minimale distorsie D(R), met R = log2 L bits/symbool. Dit betekent dat deze distorsie bereikt kan worden door elk gequantiseerd symbool voor te stellen met R bits. Echter, een meer efficiënte codering is mogelijk. De discrete bron resulterend na de quantisatie, kan beschreven worden door een set van probabiliteiten {p k }. Deze discrete bron kan gebruikt worden om een Huffman-code te ontwerpen (entropiecodering). De efficiëntie van de code kan dan vergeleken worden met de distortion-rate functie of met de rate-distortion functie van de analoge bron.

3.7.3 Vectorquantisatie In de vorige sectie hebben we de quantisatie van een analoge bron symbool per symbool uitgevoerd. In deze sectie beschouwen we de gezamenlijke quantisatie van een blok van symbolen. Deze manier van quantiseren noemt men blok- of vectorquantisatie. Deze methode wordt veel gebruikt, o.a. bij het coderen van spraak in mobiele telefonie. Een fundamenteel resultaat van de theorie van rate-distortion is dat w anneer men vectoren quantiseert, het resultaat altijd beter is (of hetzelfde) dan wanneer men scalaire 67

quantisatie toepast, zelfs wanneer de bron geheugenloos is. Verder, indien de opeenvolgende symbolen van een bron statistisch onafhankelijk zijn, dan kan men deze afhankelijkheid uitbuiten door een blok v an symbolen gezamenlijk te quantiseren, zodat we een nog grotere efficiëntie bekomen (een lager debiet) dan bij scalaire quantisatie. Het probleem v an vectorquantisatie kan als volgt beschreven worden. We hebben een n-dimensionale vector X = [x 1 x2 ... xn], met componenten met reële continue amplitudes {x k , 1 < k < n} die beschreven worden door de gezamenlijke distributie p(x 1i x2 , ... , x n ). De vector X wordt gequantiseerd in een andere n-dimensionale vector X met componenten {x k , 1 < k < n}. We drukken de quantisatie uit als Q(.): = Q(X)

(3.41)

waarbij X de uitgang is v an de vectorquantisator w an neer de ingang gegeven is door X. Vectorquantisatie kan beschouwd worden als een patroonherkenningsprobleem, waarbij blokken van data moeten geclassificeerd worden in een aantal categoriën, de cellen, zodat een of an der criterium geoptimaliseerd word, bijvoorbeeld de gemiddelde kwadratische distorsie. Bijvoorbeeld, beschouwen we de quantisatie v an een tweedimensionale vector X = [xi x2]. De tweedimensionale ruimte wordt verdeeld in cellen zoals in figuur 3.16, waarbij we willekeurig een aantal zeshoekige cellen {Ck} hebben gekozen. Alle vectoren die binnen een cel Ck vallen worden gequantiseerd als de vector Xk, dat in figuur 3.16 aan geduid wordt als het centrum van de zeshoek. In het voorbeeld zijn er L = 37 vectoren Xk, waarbij elke vector overeenstemt met één van de 37 cellen van de tweedimensionale ruimte. We noemen de set van mogelijke gequantiseerde vectoren {X k ,1 < k < L}. In het algemeen zal de quantisatie van een n-dimensionale vector X in een ndimensionale vector X aanleiding geven tot een quantisatiefout of distorsie d(X, X). De gemiddelde distorsie per dimensie (over de set v an ingangsvectoren X) is gegeven door D=

> P(X E Ck)E[d(X, Xk)|X E

Ck]

k=1

P(X E Ck) k=1

f ECkEd(X, Xk)p(X|X E Ck)dX

(3.42)

waarbij P(X E Ck) de waarschijnlijkheid is dat de vector X in de cel Ck valt, en p(X) de gezamenlijke distributie is van de n toevalsgrootheden wanneer X in de cel Ck valt. Zoals in het geval van scalaire quantisatie kan men de distorsie per dimensie D minimaliseren door de cellen {Ck, 1 < k < L} goed te kiezen voor een gegeven p(X). We definiëren de totale distorsie van de vector als de som van de distorsies per dimensie. Een veelgebruikte distorsiemaat (per dimensie) is de gemiddelde kwadratische fout, gedefinieerd als n

d2 (X, X)

E(xk — ik ) 2 = n (X — X)T(X — X) = — n k-1 68

(3.43)

Figuur 3.16: Voorbeeld van quantisatie in de tweedimensionale ruimte of meer algemeen, de gewogen gemiddelde kwadratische fout d2w(X, X) _ (X — X) TW(X — X)

(3.44)

waarbij W een positief definiete gewichtsmatrix voorstelt. Meestal wordt W gekozen als de inverse van de covariantiematrix van de vector X. Andere, minder gebruikte distorsiematen zijn

dp (X,X) = 1 — xk| p n k=1 1xk waarbij p een positief geheel getal is. Het speciale geval p = 1 wordt soms gebruikt als alternatief voor p = 2. Beschouwen we nu het probleem van de verdeling van de n-dimensionale ruimte in < L}, zodat de gemiddelde distorsie (per dimensie), voor gegeven L cellen {Ck ,1 < k _ L, geminimaliseerd wordt. Er zijn twee voorwaarden waara an voldaan moet zijn voor optimaliteit. De eerste is dat de quantisator de dichtstbijzijnde buur moet kiezen, m.a.w. Q(X) = Xk

enkel en alleen indien

D(X, Xk) < D(X, X; ) 69

k j, 1 < k< L

De tweede voorwaarde nodig voor optimaliteit is dat elke uitgangsvector Xk zo moet gekozen worden zodat de gemiddelde distorsie (per dimensie) in de cel Ck geminimaliseerd wordt. M.a.w., Xk is de vector in Ck die

X)|X E

Ck] =

f

Dk = E[d(X, d(X,

Eiik

X)p(X)dX

minimaliseert. De vector Xk die Dk minimaliseert is het zwaartepunt van de cel. Deze voorwaarden voor optimaliteit kunnen gebruikt worden om de n-dimensionale ruimte op te delen in cellen {Ck, 1 _ < k < L} wanneer de gezamenlijke distributie p(X) gekend is. Het is duidelijk dat het opleggen van deze twee voorwaarden een generalisatie is van het scalaire quantisatieprobleem naar het n-dimensionale vectorquantisatieprobleem. In het algemeen verwachten we dat de vectoren dichter bij elkaar zullen liggen in gebieden waar de gezamenlijke distributie groot is, en verder v an elkaar waar de gezamen lijke distributie klein is. De distortion-rate functie, die in de vorige sectie gedefinieerd werd voor scalaire quantisatie, kan men ook definiëren voor vectorquantisatie. Stel dat we een n-dimensionale vector X vormen door n opeenvolgende symbolen {x m } te nemen. De vector X wordt dan gequantiseerd in X = Q(X), waarbij X een vector is uit de set {Xk, 1 < k < L}. Zoals eerder vermeld, is de gemiddelde distorsie (per dimensie) D door het voorstellen v an E[d(X, X)], waarbij d(X, X) de distorsiemaat per dimensie is, Xdorgevn bijvoorbeeld n

d(X, X) = n

^ (xk

— xk) 2

k=1

De vectoren {4,1 < k < L} kunnen verstuurd worden aan een gemiddeld debiet R=

H(X) bits/symbool n

(3.45)

waarbij H(X) de entropie is van de gequantiseerde bronuitgang, H(X) = - E P

otti) log2 P(Xi )

(3.46)

i =1 Voor een gegeven debiet R is de minimale mogelijke distorsie per dimensie Dn (R) Dn (R) = minE[d(X, X)] Q(X)

(3.47)

waarbij R > H(X)/n, en het minimum genomen wordt over alle mogelijke afbeeldingen Q(X). In de limiet, wanneer het aantal dimensies n naar oneindig gaat, bekomen we D(R) = lim Dn (R) n-roo

70

(3.48)

waarbij D(R) de distortion-rate functie is die geïntroduceerd werd in de vorige sectie. Het is duidelijk uit deze afleidingen dat de distortion-rate functie willekeurig dicht benaderd kan worden door de dimensie van de vectoren te laten toenemen. De vorige afleiding is gebaseerd op de veronderstelling dat de gezamenlijke distributie p(X) gekend is. Echter, in veel gevallen kent men deze gezamenlijke distributie niet. In dit geval kan men op een adaptieve manier toch de gequantiseerde uitgangsvectoren kiezen door een set van trainingsvectoren te gebruiken. Stel bijvoorbeeld dat we een set van M trainingsvectoren hebben, waarbij M veel groter is dan L (M » L). Dan bestaat er een iteratief algoritme dat losgelaten kan worden op de set van trainingsvectoren. Dit algoritme verdeelt op een iteratieve manier de M trainingsvectoren in L groepen zodat de twee nodige voorwaarden voor optimaliteit voldaan zijn.

Iteratief algoritme Stap 1 Initialiseer het algoritme door i = 0 te stellen. Kies een set v an uitgangsvectoren Xk(0),1 < k < L. < m < M} in de clusters Stap 2 Classificeer de trainingsvectoren {X(m), 1 _ {Ck} door de regel van de dichtste buur toe te passen: X

E

Ck(i) iff

D(X, Xk (i)) < D(X, Xj (i)),

Vk

#j

Stap 3 Herbereken (set i naar i + 1) de uitgangsvectoren van elke groep door het zwaartepunt te berekenen v an de vectoren die in elke groep zitten. Xk (i)= 1 Mk

X(m),

1< k
XECk

Herbereken ook de resulterende distorsie

D(i) bij de i-de iteratie.

Stap 4 Stop het algoritme indien D(i — 1) — D(i) voldoende klein is. Indien dit niet zo is, ga naar stap 2. Dit iteratief algoritme convergeert naar een lokaal minimum. Door het algoritme te initialiseren met verschillende sets van uitgangsvectoren {X k (0)} en voor elk van deze keuzes het iteratief algoritme uit te voeren, is het mogelijk een globaal minimum te vinden. Echter, het rekenwerk vereist om dit algoritme uit te voeren k an het aantal initialisaties limiteren. Eenmaal de uitgangsvectoren 04,1 < k < L} gekozen zijn, wordt elke vector X(m) gequantiseert in de dichtstbijzijnde uitgangsvector. Indien we de afst an d tussen X(m) en alle L mogelijke uitgangsvectoren {X k } moeten berekenen, dan spreken we over een full search. Stel dat voor elke berekening er n optellingen en vermenigvuldigingen nodig zijn, dan is de rekencomplexiteit voor een 'full search' gegeven door

C=nL 71

optellingen en vermenigvuldigingen per ingangsvector. Indien L een macht van twee is, dan is log 2 L het aantal bits dat nodig is om een vector voor te stellen. Indien R het aantal bits is per symbool (per dimensie van X(m)), dan is nR = log2 L, zodat de rekencomplexiteit gegeven is door

C = n2n R Merk op dat het aantal benodigde berekeningen exponentieel toeneemt met de dimensie n en het debiet R per dimensie. Door deze hoge rekencomplexiteit kan vectorquantisatie enkel toegepast worden bij lage debieten (lage nR). De rekencomplexiteit kan verminderd worden door suboptimale algoritmen te gebruiken in plaats van het full search algoritme. Om aan te tonen dat vectorquantisatie tot betere resultaten leidt dan scalaire quantisatie beschouwen we het volgende voorbeeld. Voorbeeld:

Stel dat x 1 en x2 twee toevalsgrootheden zijn met uniforme dis-

tributie p(xl,

2.- XEC x2) - P(X) = {O b elders

waarbij C het rechthoekige gebied is getoond in figuur 3.17. Merk op dat de rechthoek geroteerd is over 45° ten opzichte van de horizontale as. In figuur 3.17 worden ook de marginale distributies p(xi) en p(x2 ) getoond. Indien we x 1 en x2 onafhankelijk van elkaar quantiseren door uniforme intervallen met stapgrootte A te kiezen, d an is het aantal benodigde niveaus Ll

=L2 =

V2Q

Hieruit volgt dat het aantal benodigde bits om de vector X = [x 1 x2 1 te quantiseren gelijk is aan 2

Rx =R1 + R2=loge L1+loge L2 = l oge (a+b)2 20 Dit betekent dat scalaire quantisatie van elke component equivalent is met vectorquantisatie met het aantal niveaus gelijk a an Lx = L1 L 2 =

(a + b) 2 202

Merk op dat deze benadering equivalent is met het opdelen van het grote vierkant dat de rechthoek omvat in vierkante cellen, waarbij elke cel één van de Lx gequantiseerde gebieden voorstelt. A an gezien p(X) = 0 behalve voor X E C is deze codering een verspilling die leidt tot een verhoging van het debiet. 72

x2^ a+b 2E

a+b 242a-b 24T 0

2 21-

E/a

^p(x1)

a+b

a-b

> xl

Figuur 3.17: Een uniforme distributie in twee dimensies Indien we enkel het gebied waarvoor p(X) # 0 bedekken met vierkanten met een oppervlakte O 2 , dan is het aantal benodigde cellen gelijk aan de oppervlakte van de rechthoek gedeeld door A2

,

L. =

ab 02

Het verschil in debiet tussen de scalaire quantisatie en de vectorquantisatie is gegeven door g2

2ab Bijvoorbeeld, indien a = 4b, d an is het verschil in debiet

Rx — Rx =

1.64 bits/vector

m.a.w. vectorquantisatie is 0.82 bits/symbool beter voor dezelfde distorsie. Merk op dat een lineaire tr an sformatie (een rotatie

ver 45°) de vectoren xx1l en x2 decorlt,zawevlsgrothdnaicfkeljwordn.Iat

geval geeft scalaire quantisatie hetzelfde resultaat als vectorquantisatie. Hoewel een lineaire transformatie een vector van toevalsgrootheden kan decorreleren, resulteert dit in het algemeen niet in statistische onafh an kelijkheid van de toevalsgrootheden. Hieruit volgt dat vectorquantisatie steeds een performantie zal hebben die gelijk is aan of beter is dan die voor scalaire quantisatie.

73

Hoofdstuk 4 Kanaalcodering 4.1 Inleiding In het model voor een digitaal communicatiesysteem, beschreven in hoofdstuk 1 (figuur 1.2), bestaat een deel van de zenderzijde uit een discrete-ingang discrete-uitgang kanlecodrgv mulator.Defncivdkaloershtinduc, op een controleerbare wijze, van redundantie in de sequentie van verstuurde bits. Deze redundantie kan dan aan de ontvanger gebruikt worden om de effecten van ruis en interferentie, geïntroduceerd door het kanaal, te corrigeren. Bij het encoderen gaat men in het algemeen k informatiebits groeperen en deze sequentie van k bits - het informatiewoord projecteren op een sequentie van n bits - het codewoord. De hoeveelheid redundantie die wordt geïntroduceerd door de encoder wordt gemeten a an de hand van het debiet Re = k/n van de code. De binaire sequentie a an de uitgang van de kanaalencoder wordt aan de modulator aangelegd, die de binaire sequentie in blokken van b bits groepeert en elk blok van b bits omzet in een datasymbool. Aan elk van deze datasymbolen wordt een golfvorm toegekend. Dit betekent dat er M = 2b verschillende golfvormen nodig zijn. Deze golfvorm wordt verstuurd over het fysische kanaal. Aan de ontvanger zet de demodulator het fysische signaal (de golfvorm), dat gecorrumpeerd kan zijn door ruis of interferentie, om in een scalair of een vector die een schatting van de verstuurde datasymbolen voorstelt. De detector, die volgt op de modulator, kan aan de hand van deze schattingen beslissen of een verstuurd bit 0 of 1 is. In dit geval heeft de detector een harde decisie genomen. Indien we het proces v an de decisie beschouwen als een vorm van quantisatie, en er twee verschillende golfvormen zijn om de bits 1 en 0 voor te stellen, dan zien we dat een harde decisie overeenkomt met een binaire quantisatie van de demodulatoruitgang. In het algemeen kan men het proces van de decisie beschouwen als een detector die de demodulatoruitgang quantiseert in Q > 2 niveaus, nl. een Q-voudige detector. Indien er M verschillende golfvormen zijn is het noodzakelijk dat Q > M. In 74

kanaal

s(t)

r(t)=s(t)+w(t) >

>+ W(t)

Figuur 4.1: Additief wit Gaussiaans kanaal het geval waarbij geen quantisatie wordt uitgevoerd geldt Q = oo. Indien Q = M spreekt men van harde decisie en wanneer Q > M spreekt men van zachte decisie. De gequantiseerde uitgang van de demodulator wordt dan aangelegd aan de kanaaldecoder, die de redundantie in de sequentie gebruikt om fouten in de sequentie te corrigeren.

4.2 Kanaalmodellen In deze sectie beschrijven we enkele kanaalmodellen die gebruikt worden bij het ontwerp van codes. We beschouwen het model voor het communicatiesysteem uit figuur 1.2. Het fysische kanaal voegt witte Gaussiaanse ruis w(t) toe aan de golfvorm s(t) (zie figuur 4.1), resulterend in een signaal r(t). Afhankelijk of de modulator en de demodulator in het kanaalmodel worden opgenomen, kunnen we drie kanaalmodellen definiëren (zie figuur 4.2): het discreet geheugenloos kanaal, het kanaal met discrete ingang en continue uitgang en het golfvormkanaal.

4.2.1 Discreet geheugenloos kanaal Het discreet geheugenloos kanaal (figuur 4.2(a)) is een kanaal met een discrete ingang en een discrete uitg ang. In het discreet geheugenloos kanaal beschouwen we de modulator en demodulator als deel van het kanaalmodel. De uitgang van de kanaalencoder wordt omgezet naar een rij van symbolen X(k) uit een q-voudig eindig alfabet (X(k) E {x1, x2 i ... , x y }) en de uitgang van de detector bestaat uit een rij van symbolen Y(k) uit een Q-voudig eindig alfabet (Y(k) E {yl , y2 , ... , yQ}), waarbij Q > M = q. Indien het kanaal en de modulatie geheugenloos zijn, hangt het symbool aan de uitgang van het discreet geheugenloos kanaal enkel af van het symbool a an de ingang op hetzelfde tijdstip. Deze statistische afhankelijkheid is onafhankelijk van de tijdsindex k (tijdsinvariant kanaal), zodat men het kanaal kan beschrijven aan de h and van de conditionele probabiliteiten P(Y = y1 |X = x.i) = P(N|xi).

(4.1)

De grafische representatie van de ingangs-uitgangskarakteristiek van een discreet geheugenloos kanaal wordt getoond in figuur 4.3. Wegens het geheugenloos karakter van het kanaal zal, indien de ingang van het k anaal gegeven is door een sequentie van n symbolen u(1), u(2), ... , u(n) en de corresponderende 75

golfvorm s(t)

symbolen X(k)

golfvorm kanaal

modulator

reële sequentie

golfvorm r(t) demodulator

quantizator

symbolen Y(k)

(a)

golfvorm

symbolen X(k)

golfvorm kanaal

modulator

reële sequentie Y(k)

golfvorm demodulator

(b)

golfvorm s(t) -r-40

golfvorm kanaal

golfvorm r(t) i

(c) Figuur 4.2: (a) Discreet geheugenloos kanaal (b) Kanaal met discrete ingang en continue uitgang (c) Golfvormkanaal

76

Figuur 4.3: Discreet geheugenloos kanaal uitgang gegeven is door v(1), v(2), ... , v(n), de gezamenlijke conditionele probabiliteit gegeven zijn door P(Y(1) = v(1), ... , Y(n) = v(n)|X (1) = u(1), ... , X (n) = u(n)) n

II P(Y = v(k)|X = u(k)).

k=1

Merk op dat de conditionele probabiliteiten die een discreet geheugenloos kanaal karakteriseren in een matrix geschreven kunnen worden: P = [pijl, waarbij P(Nixi ). Voorbeeld: Beschouw het binair symmetrisch kanaal (BSC). In dit geval zijn de ingangs- en uitgangsalfabetten dezelfde en gegeven door {0,1}. De conditionele probabiliteiten worden gegeven door P(Y=O|X =1)=P(Y=1iX =0) =p

P(Y=OIX =0)=P(Y=1|X = 1)=1—p. De grafische voorstelling van een binair symmetrisch kanaal wordt getoond in figuur 4.4.

4.2.2

K an aal met discrete ingang en continue uitgang

In het kanaal met discrete ingang en continue uitgang (figuur 4.2(b)) wordt de uitgang van de kanaalencoder omgezet naar een rij van symbolen X (k) uit een q-voudig eindig alfabet (X (k) E {x 1i x 2 , ... , xq }), en de uitgang van de detector wordt niet gequantiseerd (Q = oo). Dit betekent dat de ingang Y(k) van de kanaaldecoder elke reële waarde kan aannemen: Y(k) E { 00,+oo}. Het geheugenloos kanaal met discrete ingang en continue -

77

Figuur 4.4: Binair symmetrisch kanaal uitgang wordt gekarakteriseerd door de discrete ingang X, de continue uitgang Y en de conditionele distributies p(Y = yI X = xk) = p(y| xk),

k = 1, 2, . . . , q.

(4.2)

Voorbeeld: Het belangrijkste kanaal van dit type is het additief wit Gaussiaans ruiskanaal (AWGN). In dit geval is de uitgang van het kanaal gegeven door Y=X+W,

waarbij W een Gaussiaanse toevalsgrootheid is met gemiddelde nul en variantie Q2 , en X = xk, k = 1, 2, ... , q. Voor gegeven X is de toevalsgrootheid Y Gaussiaans verdeeld met gemiddelde xk en variantie U 2 . Hieruit volgt p(y| xk) =

1

cv 2 Z . e =0

(4.3)

27CQ

Voor een gegeven sequentie van ingangssymbolen X(i) = u(i), i = 1, 2, ... , n zal een uitgangssequentie Y(i) = X(i) + W (i)

corresponderen. De voorwaarde dat het kanaal geheugenloos is kan uitgedrukt worden als p yi,.. (

.

yn IX (1) = u(1), ...,X(n) = u(n)) n =

4.2.3

^ p(yi| X (i) = u(i)).

i= i

Golfvormkanaal

In een golfvormkanaal (figuur 4.2(c)) houden we de modulator en demodulator gescheiden van het fysische kanaal. Het kanaalmodel in dit geval heeft golfvormen als ingang en als uitgang. We veronderstellen dat het kanaal een bandbreedte W heeft met een ideale vlakke 78

frequentiekarakteristiek C(f) = 1 binnen deze bandbreedte, en dat de golfvorm verstoord wordt door additieve witte Gaussiaanse ruis. Verder, veronderstel dat s(t) de bandbeperkte (met bandbreedte < W) ingang is van het kanaal, en r(t) de corresponderende uitgang van het kanaal. In dat geval geldt r(t) = s(t) + w(t), waarbij w(t) een mogelijke uitvoering voorstelt van het additieve ruisproces. Een man ier om een set van probabiliteiten te definiëren die het kanaal karakteriseren is de golfvormen s(t), r(t) en w(t) in het interval [0, T] te projecteren op een complete set orthonormale functies. M.a.w. we schrijven s(t), r(t) en w(t) als s(t) _ > sfff(t)

r(t) =

riff (t)

w(t) =

wifi(t),

(4.4)

waarbij {si }, {ri l en {wi } de coëfficiënten zijn van de expansies

rf =

fT

J r(t) f4 (t)dt J T [s(t) + w(t)] fa (t)dt 0

=

= si + wi . De functies {ff (t)} vormen een complete orthonormale set over het interval [0, T]:

(4.5)

i i=j7 ff(t)f(t)dt=ö= 10•

Een eigenschap van witte Gaussiaanse ruis is dat elke complete set orthonormale functies kan gebruikt worden in de expansie (4.4). Bij andere types ruis zal men de Karhunen-Loeve expansie moeten gebruiken om de orthonormale basisfuncties te vinden. We kunnen nu deze coëfficiënten gebruiken om het kanaal te karakteriseren. Wegens (4.5) (ri = sf + wi, waarbij wi Gaussiaans is), volgt dat 1 e 2 oti . (4.6) 27roi Verder, omdat de functies {fi(t)} orthonormaal zijn, volgt dat de coëfficiënten {w i } ongecorreleerd zijn. Omdat deze toevalsgrootheden Gaussiaans zijn, betekent dit dat ze ook statistisch onafh ankelijk zijn. Hieruit volgt, voor om het even welke N, dat p(rf | si) =

N

p(r1, r2, . • • , rNisl, 82, . • . , sN) = jjp(riisi)•

i =1

79

(4.7)

Op deze wijze wordt een golfvormkanaal omgevormd tot een equivalent discreet tijdskanaal, gekarakteriseerd door de conditionele distributie (4.7). Wanneer de additieve ruis wit en Gaussiaans is met spectrale dichtheid N o/2, dan zijn de varianties in (4.6) voor alle i gelijk a an Q? = N0/2. In dit geval kunnen monsterwaarden van s(t) en r(t) genomen worden a an het Nyquistdebiet v an 2W monsterwaarden per seconde, zodat si = s(i/ 2W) en ri = r(i/2W). Aangezien de ruis wit is, zijn de ruismonsterwaarden statistisch onafh an kelijk. Dit betekent dat (4.6) en (4.7) de statistiek van een bemonsterd signaal karakteriseren. Merk op dat in een interval met lengte T er N = 2WT monsterwaarden zijn. Deze parameter zal later worden gebruikt om de capaciteit van een bandbeperkt AWGN k an aal te bekomen. De keuze van het kanaalmodel hangt af v an wat we willen bestuderen. Indien we geïnteresseerd zijn in het ontwerp en de analyse van de performantie van de discrete kanaalencoder en -decoder, dan kan men de kanaalmodellen gebruiken waarbij de modulator en demodulator in het kanaalmodel opgenomen worden. Echter, indien we geïnteresseerd zijn in het ontwerp en de analyse v an de performantie van de digitale modulator en demodulator, is het noodzakelijk het golfvormkanaal te gebruiken als kanaalmodel.

4.3 Capaciteit van een kanaal 4.3.1 Discreet geheugenloos kanaal We beschouwen een discreet geheugenloos kanaal met een ingangsalfabet X E {x1, x2, ... , xq }, een uitgangsalfabet Y E {yi , y2i ... , yQ }, en de set van probabiliteiten P(yi ' xi ) gedefinieerd in (4.1). Stel dat het symbool x3 werd verstuurd en dat het symbool yi werd ontvangen. De mutuele informatie geleverd over het optreden van X = xi door het observeren v an Y = yi is I(xj ; yi) = log[P(yi |x; )/P(yi)], waarbij ( ( P(yi) = P(Y = ^✓i) = E P(xk)P(yiixk)• k=1

Hieruit volgt dat de gemiddelde mutuele informatie geleverd door de uitgang Y over de ingang X gegeven is door Q

I (X ; Y) = H(X) — H(X|Y) =

E E P(x,i)P(yi j =1

i =1

Jii x i ) ^x^) log P(2

P(yi)

(4.8)

Het kanaal bepaalt de overgangsprobabiliteiten P(yi |xi ), maar de probabiliteiten van de ingangssymbolen worden bepaald door de kanaalencoder. De gemiddelde mutuele informatie, gemaximaliseerd over de set van ingangsprobabiliteiten P(xj ), is een grootheid die enkel afh angt van de karakteristieken v an het discreet geheugenloos k an aal via de 80

overgangsprobabiliteiten P(yilxj). Deze grootheid wordt de capaciteit C1 van het kanaal genoemd. M.a.w. de capaciteit van het discreet geheugenloos kanaal is gedefinieerd als Cr = max I (X; Y) P(mi) -

q P(yi ^ x,i) xi)p(ytilxj) 1og P(¢j E E P( P(xi)p(yti|xj)1ogquentie r p(ya) •

(4.9)

j-i i=1

De gemiddelde mutuele informatie /(X; Y) wordt gemaximaliseerd onder de voorwaarden P(x3 ) > 0 EP(xi) = 1. i=1

De capaciteit Ci wordt uitgedrukt in bits per ingangssymbool (indien de b as is van het logaritme 2 is) of in nats per ingangssymbool (indien het natuurlijke logaritme, met b as is e wordt gebruikt). Indien om de TS seconden een symbool over het kanaal wordt verstuurd, is de capaciteit in bits/s of nats/s gelijk aan C = C,/Ts . een

Voorbeeld:

r symmetrisch kanaal met overgangsprobabiliteiten P (0|1) = P(1I0) P(0I1) P(1|0) = p,

is de gemiddelde mutuele informatie maximaal wanneer de ingangsprobabiliteiten gegeven zijn door P(0) = P(1) = 1/2 (zie hoofdstuk 2). De capaciteit van het binair symmetrisch kanaal (in bits/ingangssymbool) is dus C7

=plog2p+( 1 -p)log2( 1 — p) =1 — 7-1(p),

waarbij 7-t(p) de binaire entropiefunctie is. De capaciteit C1 wordt in figuur 4.5 uitgezet als functie van p. Merk op dat voor p = 0 de capaciteit van het kanaal 1 bit/kanaalgebruik is. Verder zien we dat voor p = 1/2 de gemiddelde mutuele informatie nul wordt, zodat ook de capaciteit nul is. Voor 1/2 < p < 1 kunnen we de positie van 0 en 1 omkeren aan de uitgang van het kanaal, zodat C1 symmetrisch wordt ten opzichte van het punt p = 1/2. Het binair symmetrisch kanaal kan beschouwd worden als een samengesteld kanaal waarbij de modulator en demodulator opgenomen zijn in het kanaalmodel, met harde decisie aan de demodulatoruitgang. De modulator zet 1 bit om in een datasymbool +A indien de bit 1 is, en —A indien de bit 0 is. Er zijn dus twee golfvormen nodig om de informatie te versturen over het fysische kanaal. Het fysische kanaal voegt witte Gaussiaanse ruis toe met gemiddelde nul en spectrale dichtheid N 0/2. Aan de ing an g van de demodulator i = fA+wi, bekomen we, na bemonstering aan het Ny 81

Capaciteit C1 (bits/kanaalgebruik)

0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0 0.2

0.4

0.8

0.6

1

Foutprobabiliteit, p Figuur 4.5: Capaciteit voor een b air symmetrisch kanaal als functie van de foutprobabiliteit p waarbij w, wi Gaussiaans verdeeld is met gemiddelde nul en variantie N 0 /2. De een beslissing over de detector neemt aan de hand van de ontvangenrie sequen verstuurde bit: = 1 indien r; > 0 bit 0 indien r, < 0. De energie die verstuurd wordt per bit is Eb = A2 . Berekenen we de kans dat een foutieve beslissing wordt genomen bij dit kanaal, dan bekomen we de overgangsprobabiliteit p van het equivalent binair symmetrisch kanaal. De kans tvanger indien 1 werd verstuurd is gegeven door dat gekozen p=P(0|1) = P(ri<0Is,=+ p=P(0I1) <0|s i=+ A) fc

J

1

cri-A) 2

iNo e Q (J2Eb No ' 00

No

dri

waarbij r +00

1

Q(x) =

ta

27f

x

de complementaire errorfunctie is van een Gaussiaans verdeelde grootheid met gemiddelde nul en variantie 1. In figuur 4.6 wordt de Q(x) functie getoond 82

als functie van zijn argument. Op dezelfde wijze kan men P(1|0) bepalen. We vinden p = P(O|1) =P(1|0). De overgangsprobabiliteit p is een monotone functie van de signaalruisverhouding Eb/No en daalt sterk bij toenemende Eb/No (figuur 4.7(a)). Indien we de capaciteit C1 uitzetten als functie van de signaal-ruisverhouding (figuur 4.7(b)), dan zien we dat de capaciteit monotoon stijgt indien Eb/No stijgt.

4.3.2 Kanaal met discrete ingang en continue uitgang We beschouwen nu het geheugenloze AWGN kanaal in de discrete tijd met overgangsprobabiliteiten gedefinieerd in (4.3). De capaciteit van dit kanaal in bits per kanaalgebruik is de maximale gemiddelde mutuele informatie tussen de discrete ingang X E {x1, x2, ... , x 9 } en de continue uitgang Y E { oo, +oo}: —

v

+°°

C

p(yI x p(y| P(xi)p(y|x.i log P(xi)p(ylx .i )

^

(4.10)

' )

p(y )

waarbij

|

P(xk)p(yI (xk)p(y xk)• p(y) = E P k =1

Voorbeeld: We beschouwen een AWGN kanaal met binaire ing an g, waarbij de ingang de waarden X = +A en X = —A kan aannemen. De gemiddelde mutuele informatie wordt maximaal wanneer de ingangsprobabiliteiten gegeven citeit vanp(y|kanaal in zijn door P(X = +A) = P(X = —A) = 1/2. De bits/kanaalgebruik is dan

1 +^ p(y| p(yI C1 = 2 f p(y + A) 1Qg

p(y)

)

1 +^

dy + 2 f

p(y| p(yI

A) log

p(yI — A)

p(y)

dy.

In figuur 4.8 wordt de capaciteit C1 getoond als functie van de signaalruisverhouding Eb/No, waarbij Eb = A2 de energie verstuurd per bit is, en N0/2 de variantie van de ruis. Merk op dat de capaciteit monotoon stijgt van 0 tot 1 wanneer de signaal-ruisverhouding toeneemt. Merk op dat voor de twee kanaalmodellen die in de voorbeelden hierboven beschreven zijn de gemiddelde mutuele informatie maximaal wordt wanneer de ingangssymbolen alle even waarschijnlijk zijn. Dit betekent dat de kanaalcapaciteit bekomen wordt wanneer alle symbolen even waarschijnlijk zijn. In het algemeen zal de gemiddelde mutuele inforolen. De reden en waarschijnlijke matie echter niet maximaal worden voo 83

1.E+00 LE-01 1.E-02 1.E-03 1/2 exp(-x2/2) LE-04 1.E-05

Q(x) N

1.E-06 1.E-07 1.E-08 1.E-09 1.E-10 1.E-11 1.E-12 1.E-13 LE-14 1.E-15 0

1

3

4

5

x

Q(x) <_ 1/2 exp(-x 2/2)

Figuur 4.6: De foutfunctie Q(x)

84

6

7

0.5

Foutprobabiliteit, p

0.4 0.3 0.2 0.1

-40

-30

-20

-10

0

10

Signaal-ruisverhouding, Eb/No (dB) (a) Capaciteit, CI (bits/kanaalgebruik)

1 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1 0

-30

-20

-10

0

10

20

Signaal-ruisverhouding, Eb/No (dB) (b)

Figuur 4.7: (a) De foutprobabiliteit p en (b) de capaciteit Ci als functie van Eb/No voor een binair symmetrisch kanaal

85

Signaal-ruisverhouding, Et /No (dB) Figuur 4.8: De capaciteit C1 als functie van Eb/No voor een geheugenloos AWGN kanaal met binaire ing an g waarom in de twee voorbeelden de capaciteit bereikt wordt wanneer alle symbolen even waarschijnlijk zijn is de symmetrie van het beschouwde kanaal. Hierdoor ontstaat er ook een symmetrie in de uitdrukking voor de gemiddelde mutuele informatie /(X; Y) en wordt deze maximaal wanneer alle ingangssymbolen even waarschijnlijk zijn. Vertalen we de symmetrievoorwaarde naar de matrix P van kanaalprobabiliteiten van een discreet geheugenloos kanaal, dan vinden we dat elke rij in de matrix een permutatie moet zijn van elke an dere rij van de matrix, en elke kolom in de matrix moet een permutatie zijn van elke andere kolom in de matrix. In dat geval wordt de gemiddelde mutuele informatie gemaximaliseerd wanneer alle ingangssymbolen even waarschijnlijk zijn. In het algemeen kunnen we voor een discreet geheugenloos kanaal een nodige en voldoende voorwaarde opstellen voor de set van ingangsprobabiliteiten {P(x j )} die I(X; Y)

86

maximaliseren, dus de ingangsprobabiliteiten waarvoor de capaciteit bereikt wordt, nl.: /(xxj; 3 ; Y) = Cr /(x3 ; Y) < CI /(xj;

voor alle j waarvoor P(x3 ) > 0 voor alle j waarvoor P(x3 ) = 0,

(4.11)

waarbij CI de capaciteit van het kanaal is, en Q

P(yiI xi) P( yi|

E P(yilxJ) log I(x.i}Y)= I(x.i}Y)=EP(yi|xJ)log P(yi) i =i

(4.12)

Het is zeer eenvoudig na te gaan of het geval waarbij alle ingangssymbolen even waarschijnlijk zijn voldoet aan de voorwaarde (4.11). Indien dit niet zo is, dan moet een set {P(x 3 )} van niet even waarschijnlijke ingangsprobabiliteiten gezocht worden die voldoet aan (4.11). 4.3.3

Golfvormkanaal

We beschouwen nu een bandbeperkt golfvormkanaal met additieve witte Gaussiaanse ruis. De capaciteit v an het kanaal per tijdseenheid werd gedefinieerd door Shannon als C = lim max 1 I (S• R), T-4o0 p(s) T '

(4.13)

waarbij de gemiddelde mutuele informatie gegeven is door (2.24). We kunnen echter ook monsterwaarden van de golfvormen s(t), r(t) en w(t), of de coëfficiënten van de projectie van e golfvormen op een complete orthonormale set, gebruiken om de gemiddelde mutuele informatie tussen sN = [s ist • • • sN] en rN = [ri r2 rN] te bepalen, waarbij N = 2WT, ri = si + wi , en p(ri I| si ) gegeve is door (4.6). De gemiddelde mutuele informatie tussen sN en rN voor het AWGN kanaal is gegeven door I (SN; RN)

= LN

_ N

J N p(rNI SN)p(sN) p(rN| log

^O (r N

pl

N)

+^

^ oo f c° i=i f^

p(ri I si )p(s i ) l og

pp^

drN dS

N)

I| j ) dridsi,

(4.14)

waarbij p(ri|si) = p(rilsi)

1 e

No

•

(4.15)

No Het maximum va/(S; R) ove ingangsdistributies p(si) wordt bekomen wanneer de coëfficiënten { si } statistisch onafhankelijk zijn en Gaussiaans verdeeld zijn ^

1 —

27fUs

87

e_^

(4.16) '

waarbij

vs

de variantie is van elke s = . Dan volgt uit (4.14) dat z

max I(SN; RN) =

E 21og (/ 1 +

p(s)

t=i

\

NS

I

z / log( 1+ N5) \ o z = WT log 1 + Ns/ No

=2

(4.17)

Stel dat het gemiddelde vermogen van de verstuurde golfvorm gelijk moet zijn aan P ay :

Pay =

fT T 1

E[sz(t)jdt

N

E[szI T^ 4=i _ No T

zodat T PQ„ N Pay

(4.18)

2W .

Substitueren we dit resultaat in (4.17), dan bekomen we

m(ax I(SN; RN) =

WT log (1 +

Pay

J.

(4.19)

De capaciteit per tijdseenheid wordt bekomen door het resultaat in (4.19) te delen door T: C=

W log (1 +

Way .

(4.20)

Deze basisformule voor de capaciteit van eenbandbeperkt AWGN golfvormkanaal waarvan het gemiddelde vermogen van de ingang beperkt is, werd voor het eerst afgeleid door Shannon. In figuur 4.9 wordt de capaciteit in bits/s, genormaliseerd ten opzichte van de bandbreedte W, uitgezet als functie van het signaal-ruisvermogen - dit is het gemiddeld signaalvermogen Pay gedeeld door het ruisvermogen WN o . Merk op dat de capaciteit monotoon toeneemt wanneer het signaal-ruisvermogen toeneemt. Dit betekent dat voor gegeven bandbreedte en ruisvermogen de capaciteit van het golfvormkanaal zal toenemen wanneer 88

C/W [(bits/s)/Hz] -10

-5

0

5

10

15

20

Pav/WNo ( dB )

Figuur 4.9: Genormaliseerde kanaalcapaciteit als functie van de signaal-ruisverhouding voor een bandbeperkt kanaal het signaalvermogen toeneemt. Anderzijds, w an neer het gemiddeld signaalvermogen constant wordt gehouden, dan kan de capaciteit verhoogd worden door de bandbreedte te laten toenemen. Figuur 4.10 toont de capaciteit C als functie van de bandbreedte W voor een gegeven signaalvermogen. Merk op dat wanneer de bandbreedte naar oneindig gaat, de capaciteit een as ymptotische waarde bereikt: C°°

= Ny0 l oge e = Noin 2 (bits/s).

(4.21)

We kunnen de genormaliseerde kanaalcapaciteit C/W uitdrukken als functie van de signaal-ruisverhouding per bit Eb/No. A an gezien Pay het gemiddelde verstuurde vermogen is, en C het debiet in bits/s, volgt dat

Pay = CEb,

waarbij

Eb de energie per bit is. Hieruit volgt dat (4.20) kan geschreven worden als C V

= 1og2(1+ C V No ) , 89

(4.22)

W (Hz)

Figuur 4.10: Kanaalcapaciteit als functie van de bandbreedte voor een vast zendvermogen en

Eb 2C/W — 1 No C/W

(4.23)

Indien C/W - 1 dan is Eb/No = 1 (0 dB). Indien C/W -3 cc, dan Eb No

2 C/W C/W

exp( W ln2-ln )J. Hieruit volgt dat Eb/No exponentieel toeneemt wanneer C/W -* co. Anderzijds, indien C/W -* 0 dan Eb

2C/W — 1

= In 2, No c w o C/W wat gelijk is aan -1.6 dB. In figuur 4.11 wordt C/W als functie van Eb/No getoond.

/

4.4 Kanaalcoderingstheorema 4.4.1 Ongelijkheid van Fano Beschouw een discreet geheugenloos kanaal met gelijke ingangs- en uitgangsalfabetten met q = Q = N elementen. In dit geval kunnen we de gemiddelde foutprobabiliteit van het 90

C/W [(bits/s)/Hz]

10

1

0.1 -2

0

6

8

10

12

14

16

18 20

Eb/No (dB)

Figuur 4.11: De capaciteit C als functie van Eb/No voor een bandbeperkt kanaal

91

discreet geheugenloos kanaal definiëren als N

P(e) _

E E

(4.24)

j =1 i=1 ,i0

terwijl de probabiliteit dat een symbool dat werd verstuurd over het kanaal correct werd ontvangen gelijk is aan N

P(c) =1 — P(e) =

E P(xi, yi).

(4

i =1 H(X|Y). Beide Verder wordt de dubbelzinnigheid van een discreet kanaal gegeven door H(XIY). kunnen gebruikt worden als maat voor de kwaliteit van het kanaal. Het verband tussen beide grootheden kan worden gevonden als volgt. Eerst definiëren we de entropie 74(e) als de entropie van een binaire bron met symboolprobabiliteiten P(e) en 1 — P(e): 7-1(e) _ —P(e)

(4.26)

log P(e) — (1— P(e)) log(1 — P(e))

Deze grootheid correspondeert met de hoeveelheid informatie die nodig is om te specificeren of een fout opgetreden is bij de transmissie over een kanaal met foutprobabiliteit P(e). Het volgende theorema kan bewezen worden: Fano's ongelijkheid: Beschouw een discreet geheugenloos kanaal waarvan de ingangs- en uitgangsalfabetten X en Y hetzelfde aantal symbolen N hebben, en waarvan de foutprobabiliteit gegeven is door P(e). Dan geldt de volgende

ongelijkheid:

H(XIY) H(X|Y)< '7-t(e) + P(e) log(N

(4.27)

— 1).

theorema te bewijzen gebruiken we de definitie van de Bewijs: OH( X|Y) en de foutprobabiliteit P(e dubbelzinnigheid H(XIY) N

H (X |I Y)

=

N

1

N

(

^ ^ j=1

P xj, i) 1°g

P(xjiyi)

+^ P

yi)1Og

i=1

zodat

IY) - P(e) log(N — 1) — 4-1(e) H(X|Y) H(X N N

P(e)

E E

yi) 1og

j =1 i=1,iij

1 — P(e)

N ^

E P(xi, yi) 1og

i =1

(N

P(P(xi| P(xiI yi)

92

j Iyi)

1 P (x x|yi), xlyi)

Gebruiken we de ongelijkheid ln x < x — 1, dan bekomen we H(X 1Y) — P(e) log(N — 1) — 7{(e) N N

<

loge

EE

P(e) P(xj,yi) [(N —

j=1 i=1,i0j

N ( (1 P(e) yi) L P(xi ^ yi) + ^ P(xi, i=1 -

N N

1

1 )P(xj|yi)

1]

1} J

N

N

= log e E E P(yj) —E E P(xi , yi) i =1 N

+(1

N

— P(e)) E P(yi) — E P(xi, yi) i =1

i =1

= log e {p(e) — P(e) + (1 — P(e)) — (1 — P(e))} = 0 0

De ongelijkheid (4.27) kan op een intuïtieve wijze worden geïnterpreteerd. Het detecteren van het al dan niet optreden van een fout bij het ontvangen van een symbool y E Y neemt een onzekerheid weg gelijk aan 9-t(e). Indien geen fout is opgetreden, dan is de overb lijvende onzekerheid van het verstuurde symbool nul. Indien een fout is opgetreden, een gebeurtenis met waarschijnlijkheid P(e), dan moet men beslissen welke v an N —1 overgebleven symbolen was verstuurd om een correcte beslissing te nemen. De de onzekerheid over deze keuze kan niet groter zijn dan log(N — 1). In figuur 4.12 wordt de functie 9-t(e) + P(e) log(N — 1) getoond als functie van P(e). Aangezien H(X|Y) = H(X) — I(X;Y) levert dit theorema een ondergrens voor de foutprobabiliteit in termen v an het verschil tussen de entropie v an het ingangsalfabet X en het stromen v an de informatie door het kanaal. Aangezien I (X; Y) < C1, kan geschreven worden dat H(X) — Cj <74(e) + P(e) log(N — 1). (4.28) De functie C1 + 9-t(e) + P(e) log(N — 1) wordt getoond in figuur 4.13. In de figuur kan geobserveerd worden dat het gebied met toegelaten paren (P(e), H(X)) de punten met P(e) = 0 bevat voor H(X) < CI . Met andere woorden, indien de entropie van het ingangsalfabet de kanaalcapaciteit overschrijdt, dan is het onmogelijk om de informatie te versturen over het kanaal met een willekeurige kleine foutprobabiliteit. Dit resultaat is een

eenvoudige versie van het omgekeerde van het kanaalcoderingstheorema, dat in de volgende sectie zal worden besproken. Indien we het ingangsalfabet van het kanaal identificeren met het uitgangsalfabet van de bronencoder, dan beschrijft de voorgaande situatie het geval waarbij de symbolen aan de uitgang v an de bronencoder onver an derd door het kanaal worden gestuurd: er vindt geen kanaalcodering plaats. In de volgende stap breiden we de voorgaande resultaten uit door kanaalcodering in beschouwing te nemen. 93

P(e)

1-1 N

Figuur 4.12: De functie '1-1(e)+ P(e) log(N — 1) als functie van P(e)

H(X) ♦

^^^'

f

toegelaten bid voor ghet paar j P(e) H(1\

J

////e / /

^ ►

P(e)

Figuur 4.13: De functie C1+ 7-1(e) + P(e) log(N — 1) als functie van P(e) 94

KANAAL ENCODER

BRON W

X

KANAAL

KANAAL DECODER

GEBRUIKE

z

Y

Figuur 4.14: Model van een discreet communicatiesysteem 4.4.2

Omgekeerde van het kanaalcoderingstheorema

Beschouw het systeem uit figuur 4.14, waarbij het blok 'BRON' de cascade van de bron en bronencoder voorstelt. Stel voor alle eenvoud dat de uitgang van de bron een sequentie is van binaire symbolen die verstuurd worden elke Ts seconden. De kanaalencoder is een binaire blokencoder (zie hoofdstuk 5). De kanaalencoder zet een blok van k opeenvolgende symbolen afkomstig van de bron (een blok van k symbolen wordt een woord genoemd) om in een blok van n symbolen, dat verstuurd wordt over het kanaal. Het debiet R c van de code wordt gedefinieerd als Rc o k (4.29) n A an gezien er n symbolen moeten verstuurd worden over het kanaal elke kTs seconden, moet het kanaal gebruikt worden elke Tc = RcTs seconden. Noemen we W de set van 2 k an de ingang van de kanaalencoder, en Z de set van 2k berichten aan de uitgang berichtna van de decoder, dan kunnen we de ongelijkheid van Fano gebruiken voor deze twee sets: H(W I Z) < 9-1,,(e) + PP (e) log(2k — 1).

(4.30)

waarbij 74w (e) de entropie is van een binair alfabet met symboolprobabiliteiten PP(e) en 1 — Pw (e), en waarbij de index w in Pis (e) en ?-lw (e) slaat op het feit dat woorden worden verstuurd, en Pw (e) de gemiddelde probabiliteit v an het verkeerd decoderen van een woord voorstelt. Verder, aangezien H(WIZ) H(W|Z) = H(W) — I(W; Z), en rekening houdend met de lijkheid (zie sectie 2.3; deze ongelijkheid zegt dat het onmogelijk is om de volgend onzekerheid over een bericht te verminderen door het op een of andere manier te verwerken = dataprocessortheorema): I(W; Z) < I(X; Y), 95

bekomen we dus (4.31) Aangezien de transmissie v an elk blok van k symbolen vereist dat er n keer gebruik wordt gemaakt v an het kanaal kunnen we ook schrijven dat H(WJZ) > H(W) — I(X;Y).

(4.32)

I (X; Y) < nCj.

Na substitutie v an (4.32) en (4.31) in (4.30) bekomen we dat H(W) — nC j < 7-1(e) + Pv,(e) log(2k — 1).

(4.33)

Deze ongelijkheid wordt het omgekeerde van het kanaalcoderingstheorema genoemd. Aangezien het alfabet W wordt bekomen door het groeperen van k opeenvolgende symbolen aan de uitgang van de bron, is de entropie H (W) gegeven door (4.34)

H(W) = kH„„(L),

waarbij Heo (L) de entropie is van de bron. Een ondergrens op de foutprobabiliteit kan afgeleid worden uit (4.33) en (4.34) als volgt: Pw(e)

> kl „„(L) — nCj — 7-1(e) > kH„„(L) — nCj — 1 log(2k — 1)

k

— Hoo(L) —

Cj

— 1.

k

(4.35)

Laten we nu k en n naar oneindig gaan terwijl we hun verhouding R, constant houden, dan bekomen we Pw(e) > HH(L) — Ré . (4.36) De ongelijkheid (4.36) zegt dat de probabiliteit van het verkeerd decoderen van een sequentie van k bronsymbolen niet willekeurig klein kan worden gemaakt indien het debiet van de encoder groter is dan de verhouding Cj/Hoo (L). De bovenstaande a fl eidingen gelden voor de woordfoutprobabiliteit, m.a.w. de kans dat een woord verkeerd wordt gedecodeerd. We wensen deze ondergrens uit te breiden voor de bitfoutprobabiliteit, m.a.w. de k an s dat een binair bronsymbool verkeerd wordt afgeleverd aan de gebruiker. Gebruiken we de notaties uit figuur 4.14, d an is de bitfoutprobabiliteit gedefinieerd als Pb (e) == P[(i ai], m.a.w. de kans dat een bronsymbool foutief is na decodering. Voor de eenvoud veronderstellen we dat de binaire bronsymbolen onafhankelijk zijn, dezelfde distributie hebben en alle even waarschijnlijk zijn. Dan kunnen we de ongelijkheid van Fano gebruiken om de volgende uitdrukking te bekomen /(Ai;(7,) = H(A) — H( 7i|(i) = 1 — H(ai|(i) ? 1— 7 4(e),

(4.37)

waarbij 7-4(e) de entropie is van een binair alfabet met symboolprobabiliteiten Pb(e) en 1 — Pb(e). Verder, gebruik makend van (4.37), kan men bewijzen dat k

I(W |Z)

I(Ai;(i) > k[1 — 7-1 b(e)]•

?

i =1 96

(4.38)

Tenslotte merken we op dat, gebaseerd op het dataprocessortheorema, de volgende ongelijkheden gelden: I (W |Z) < /(X; Y) < nCI. (4.39) Combineren we dit met (4.38), dan bekomen we R^

CI = < n 1 — 9-ib(e) •

(4.40)

De bovengrens (4.40) is een dalende functie van de bitfoutprobabiliteit via de noemer van het rechterlid. Dit was te verwachten, aangezien dit betekent dat hoe betrouwbaarder men wenst te communiceren, hoe trager men moet communiceren. Uit (4.40) kunnen we een ondergrens voor de bitfoutprobabiliteit a fleiden, analoog als (4.36), in de vorm

Pb > WW1 I 1 — Rc = 7-4- 1

C1—

^

Ri

,

(4.41)

waarbij C = CIHco (L) en R = RcHOQ (L) respectievelijk de capaciteit van het kanaal en het debiet van de kanaalencoder zijn uitgedrukt in bits/s. 4.4.3 Kanaalcoderingstheorema In het voorgaande hebben we bewezen dat er een ondergrens, verschillend van nul, bestaat op de bitfoutprobabiliteit, wanneer het debiet R = RcHoo (L) van de kanaalencoder groter is dan de capaciteit C van het kanaal. Dit is het 'negatieve' resultaat gekend als het omgekeerde van het kanaalcoderingstheorema. W anneer het debiet R van de kanaalencoder kleiner is dan de capaciteit van het kanaal, dan wordt het gedrag van het systeem bepaald door het kanaalcoderingstheorema. Het bewijs van dit theorema werd voor het eerst geleverd door Shannon in 1948. (zonder bewijs): Beschouw een binaire bron met entropie Hoo (L) bits/symbool en een discreet geheugenloos kanaal met capaciteit C, dan bestaat er een code met debiet R, = kin waarvoor de woordfoutprobabiliteit begrensd is door Pw (e) < 2 -2nE(R) (4.42) R = Rc Hoo (L), waarbij E(R) een convexe, dalende, niet-negatieve functie is v an R voor 0 < R < C. Theorema

97

De functie E(R) wordt de random coding exponent genoemd, en wordt gedefinieerd als (4.43)

E(R) = max max [Eo (p, P(xi )) —

waarbij

Q Eo(P, P(xï))

1+p

q

)P(yi|xk)r] Y iIxk)r P = — in>[P(xk E P(xk)P( [

]

(4.44)

i=1 k=1

Het typische gedrag van E(R) wordt getoond in figuur 4.15. Gebaseerd op (4.42) kunnen we op drie manieren de performantie van een communicatiesysteem verbeteren: 1. Laat R afnemen door R, = k/n te verlagen. Dit betekent dat de redundantie geïntroduceerd door de code moet toenemen en, voor een vast brondebiet, het k an aal meer te gebruiken. Met andere woorden, we hebben een kanaal met een grotere bandbreedte nodig. Wat er gebeurd wordt in figuur 4.16 getoond: we verschuiven van R1 naar R2, zodat E(R) toeneemt, en de bovengrens in (4.42) afneemt. 2. Verhoog de capaciteit v an het kanaal door de signaal-ruisverhouding in het kanaal te laten toenemen. Dit gedrag wordt getoond in figuur 4.17. Het werkingspunt verschuift v an E1 (R) naar een grotere E2(R), zodat de bovengrens verbetert. = k/n constant, maar laat n toenemen. Deze derde benadering 3. Hou het debiet vereist geen ingreep in de bandbreedte of signaal-ruisverhouding van het kanaal, waar men dikwijls geen invloed op heeft. Het laat toe de performantie van het communicatiesysteem te verbeteren door eenvoudigweg de lengte van het blok dat omgezet wordt in de kanaalencoder te laten toenemen. Laten we de bloklengte naar oneindig gaan (n —3 co), dan volgt uit (4.42) dat de bovengrens naar nul gaat. Echter, met het toenemen v an de bloklengte n verhoogt de complexiteit v an de encoder en decoder, zodat de toepassing van deze methode stuit op praktische problemen, zoals de maximaal toegelaten vertraging in het communicatiesysteem (de vertraging stijgt met de complexiteit van de encoder en decoder), en de bestaande technologie. Terwijl methodes (1) en (2) reeds welbekende methodes waren om de effecten van ruis en andere stoormechanismen tegen te gaan, is het gebruik van de derde methode te d an ken aan Shannon's theorie. 4.4.4 Samenvatting Het grote bel ang van de kanaalcapaciteiten die we bekomen hebben voor de verschillende kanalen is dus dat deze kanaalcapaciteiten een bovengrens vormen voor het informatiedebiet dat men over een kanaal met ruis kan versturen met een foutprobabiliteit nul.

98

Figuur 4.15: Typisch gedrag van E(R)

Figuur 4.16: Toename van E(R) door afname van Rc = k/n Het kanaalcoderingstheorema en zijn omgekeerde: Indien de datastroom uit de kanaalencoder R bits/s is en C bits/s de capaciteit van het kanaal, dan kan men door een geschikte keuze van kanaalcodering en -decodering, deze stroom aan de ontvanger reconstrueren met een willekeurig kleine foutprobabiliteit, op voorwaarde dat R < C. Het omgekeerde is ook waar. Is R > C, dan kan men de datastroom aan de ontvanger niet reconstrueren met een foutprobabiliteit die willekeurig klein is. Combineren we dit resultaat met het broncoderingstheorema, dan kunnen we zeggen dat voor een discrete bron waarvan de uitgang een entropie Hoo (L) heeft, deze bronuitgang perfect kan gereconstrueerd worden aan de ontvanger op voorwaarde dat het informatiedebiet R = RCHOO (L) < C, waarbij Rc het codedebiet is, en dit door geschikte 99

Figuur 4.17: Toename van E(R) door toename van de capaciteit codering/decodering. Analoog geldt voor niet-discrete bronnen dat, indien men de uitgang van de bron kan benaderen met R bits/s voor een gegeven distorsie, men deze na transmissie kan reconstrueren met dezelfde distorsie indien R < C. Het gevolg v an uitdrukking (4.41) is dat het debiet R dat men wenst te versturen over het kanaal groter mag zijn d an de capaciteit C van het kanaal, wanneer men een bepaalde bitfoutprobabiliteit Pb toelaat. Het debiet R dat men in dat geval over het kanaal mag versturen is naar boven begrensd door R

<

C 1- 7-1b(e)

In figuur 4.18 wordt de factor (1 — 7-4(e)) getoond als functie v an de toegelaten bitfoutprobabiliteit Pb. Uit de figuur leiden we af dat de factor (1 —1-4(e)) nagenoeg gelijk is aan 1 wanneer de bitfoutprobabiliteit klein is (Pb < 10-3 ). In praktische situaties willen we een betrouwbaar systeem, waarbij de bitfoutprobabiliteit voldoende klein is (Pb « 10-3 ), zodat in de praktijk het debiet R naar boven begrensd is door de capaciteit C, zelfs als een bepaalde bitfoutprobabiliteit is toegelaten ((1 — 7-lb(e)) -1 1) In figuur 4.19 worden een aantal bestaande communicatiesystemen vergeleken met de capaciteit van een additief wit Gaussiaans golfvormkanaal bij een bitfoutprobabiliteit Pb = 10 -5 . De lijst van gecodeerde systemen is terug te vinden in tabel 4.1. We observeren dat alle systemen zoals verwacht binnen het toegelaten gebied liggen. Gecodeerde systemen naderen de capaciteit van het kanaal dichter dan niet-gecodeerde systemen.

100

0.9

.-,

•-■

0.8

0.7

0.6

0.5 1.E-05

1.E-04

1.E-03

1.E-02

1.E-01

1.E+00

Pb(e)

Figuur 4.18: De factor (1 — 9-tb(e))

Tabel 4.1: Codes getoond in figuur 4.19, gemoduleerd met BPSK/DSB (behalve TCM) Toepassing Code Mariner missie, Viking missie a (32,6) Reed-Muller code b (255,123) BCH code Pioneer 9/10/11 missies c (2,1,31) convolutionele code inner code Voyager missie d (2,1,6) convolutionele code inner code Galileo missie e (4,1,14) convolutionele code Voyager missie f (2,1,6) convolutionele code + (255,223) Reed-Solomon code Galileo missie g (4,1,14) convolutionele code + (255,223) Reed-Solomon code h Rc = 2/3 trelliscode (TCM) met 8PSK modulatie i turbocodes j LDPC codes

101

C/W

10 ^ verboden gebied

M=64 M=16

QAM/D SB PSK/DSi

M=16

I

M=8

M=8

h

(D AM

P

PAM/D SB

M=1

• M=4

1

-1.6

M=2

:

.

..

) 1

.

•

. . . .

• 4

4

f

: --

^

bAll

a

•

'

toegelaten gebied 0.1 -2

0

2

4

6

8

10

12

14

16

18

Eb/No (dB)

Figuur 4.19: Vergelijking praktische communicatiesystemen met capaciteit

102

20

Hoofdstuk 5 Performantie van binaire lineaire blokcodes 5.1 Lineaire blokcodes 5.1.1 Definitie Een blokcode is een code die een informatiewoord b = (b 1 , ..., bk) van lengte k omzet in een codewoord c = (c1 , •.., e,,) van lengte n. Bij een lineaire blokcode gebeurt deze omzetting met behulp v an een lineaire transformatie: c = bG

(5.1)

waarbij de k x n matrix G de generatormatrix wordt genoemd. De generatormatrix van een lineaire blokcode is niet uniek: elke generatormatrix G' die men bekomt door bewerkingen op de rijen en permutaties op de kolommen uit te v an een generatormatrix G voeren noemt men equivalent met de generatormatrix G (de eigenschappen van de codes gegenereerd door generatormatrices G en G' zijn identiek). Hieruit volgt dat elke generatormatrix in de systematische vorm kan geschreven worden: G = [L|P],

(5.2)

waarbij Ik de k x k eenheidsmatrix is en P een k x (n — k) matrix die het verband tussen de informatiebits en de redundante pariteitsbits bepaalt. Merk op dat een generatormatrix in zijn systematische vorm steeds een code genereert waarbij de eerste k bits van het codewoord gelijk zijn aan de informatiebits en de laatste n — k bits lineaire combinaties van de informatiebits - de pariteitsbits zijn. De resulterende code wordt een (n, k) systematische code genoemd. In dit hoofdstuk beperken we ons tot binaire codes, waarbij de elementen van b, c en G enkel de waarden '0' en '1' kunnen aannemen, en de bewerkingen modul o2 bewerkingen zijn. Niet binaire codes, waarbij de elementen van b, c en G meerdere waarden kunnen aannemen, worden besproken in hoofdstuk 6. 103

We definiëren de Hammingafstand dH (a, b) tussen twee codewoorden als het aantal posities waarin beide codewoorden verschillen. Het Hamminggewicht WH(c) van een codewoord wordt gedefinieerd als het aantal niet-nulelementen in het codewoord. Indien we twee codewoorden modulo-2 optellen, dan zal het resultaat enkel een '1' bevatten in de posities waar de codewoorden verschillen. Dit betekent dat voor alle codewoorden geldt: di/ (a, b) = wH (a + b).

(5.3)

Dit resultaat impliceert dat de afstand van een codewoord tot alle andere codewoorden bepaald wordt door de gewichten van alle codewoorden. Anders geformuleerd, de afstand tussen twee codewoorden is gelijk aan de afstand tussen het nulwoord en het codewoord dat bestaat uit de som van de twee beschouwde codewoorden. Dit betekent dat, indien we de afstandsstructuur van een code willen vinden, we enkel het gewichtsspectrum van de code moeten kennen. Het gewichtsspectrum van een code wordt bepaald door de verschillende Hamminggewichten w v an de codewoorden en het aantal codewoorden A,,, voor elk gewicht. Deze informatie kunnen we op een compacte manier neerschrijven door de uitgangsgewichtsfunctie van de code te definiëren als de veelterm n

Ao(x) =

Aix`, E i=o

(5.4)

waarbij Ai het aantal codewoorden is met gewicht i. We noemen d H mtin de minimale Hammingafstand tussen de codewoorden: dH,min = min dH(ci, c7). eij;qi

(5.5)

Later in dit hoofdstuk zal aangetoond worden dat een goede code, dit is een code met een goede performantie, een grote minimale Hammingafstand heeft. Een grote Hamingfstduecowrnzgteimsvordahnwcijlksdate ruis in het kanaal aanleiding geeft tot een decodeerfout. Er geldt A o = 1 (het codewoord corresponderend met Ao is het nulwoord) en Ai = 0 voor 0 < i < dH,,,,,in . Indien we een goede code wensen te construeren met grote minimale Hammingafstand, dan moeten we ervoor zorgen dat het gewicht van de codewoorden, die verschillen van het nulwoord, zo groot mogelijk is. Wanneer een codewoord over een kanaal wordt verstuurd, ontvangt de ontvanger een ruishebbende versie van het verstuurde codewoord. In het geval van een binair kanaal kan men de ontvangen sequentie r zonder verlies a an algemeenheid schrijven als de modulo-2 som van het verstuurde codewoord c en een foutvector e, die een '1' bevat op de posities waar het kanaal een fout heeft geïntroduceerd. De ontv an ger decodeert de ontvangen sequentie door naar het dichtstbijzijnde codewoord te zoeken:

c = arg min dH (r,c), 104

(5.6)

waarbij dH(r, c) de Hammingafstand is tussen de ontvangen sequentie van bits r en het codewoord c, m.a.w. het aantal posities waarin r en c verschillen. Om het dichtstbijzijnde codewoord te vinden zal de ontvanger het syndroom s berekenen, dat gedefinieerd is als volgt: (5.7) s = rHT, waarbij H de checkmatrix van de code is. De checkmatrix van de code wordt gekozen zodanig dat ze orthogonaal is met de generatormatrix: GHT = 0,

(5.8)

Net zoals de generatormatrix is de checkmatrix niet uniek, en kan een systematische vorm van de checkmatrix worden gedefinieerd. Voor een systematische generatormatrix G = [I03 ) kan men op een eenvoudige wijze de systematische checkmatrix bepalen: H = [PT|If_k). A an gezien elk codewoord bestaat uit een lineaire combinatie van de rijen van de generatormatrix geldt: (5.9) cHT = 0. De vergelijking (5.9) levert ons een manier om te testen of een willekeurig woord r v an lengt codwrisfnet,z mogrijpenadtblmcowren. Nemen we het product rHT, dan bekomen we dat s = rHT = 0 als r een codewoord is (5.10) 0 0 als r geen codewoord is. Het syndroom s hangt enkel af van de foutvector, maar niet van het verstuurde codewoord:

s = rHT = (c + e)HT = cHT + eHT = eHT.

(5.11)

Aangezien men bij het decoderen het dichtstbijzijnde codewoord zoekt, kan men het decodeerprobleem, wegens de eigenschappen v an het syndroom, herleiden tot het zoeken v an an leiding geeft tot het bekomen syndroom. In defoutvcrmhklinsegwctda een syndroomtabel vindt men voor alle mogelijke syndromen de corresponderende foutvector met kleinste gewicht. Voorbeeld:

Beschouw de code die bepaald wordt door de generatormatrix 100101 G= 0 1 0 1 1 1 . 001011

Een equivalente generatormatrix voor deze code is gegeven door 100101 G'= 1 1 0 0 1 0 . 111001 105

Tabel 5.1: Syndroomtabel voor de (6, 3) lineaire blokcode Syndroom Coset-leider 000000 000 001 000001 000010 010 000100 100 001000 01 systematische 111 010000 100000 101 010001 110 Deze niet-systematische generatormatrix is equivalent met de eerste, systematische generatormatrix: indien men in G' de eerste rij behoudt, de tweede rij vervangt door de modulo-2 som van de eerste en de tweede rij, en de derde rij vervangt door de modulo-2 som van de eerste, de tweede en de derde rij, dan bekomen we de systematische generatormatrix G. De checkmatrix H van de code is gegeven door: 1 1 0 1 0 0 0 1 1 0 1 0 1 1 1 0 0 1

.

De syndroomtabel voor de code is gegeven in tabel 5.1. Stel nu dat het codewoord c = (100101) werd verstuurd, en het woord r = (101101) werd ontvangen. Berekenen we het syndroom, dan vinden we s = (011). In de tabel 5.1 komt dit syndroom overeen met de foutvector e i = (001000). Tellen we deze foutvector op bij het ontvangen woord, dan bekomen we inderdaad het codewoord c = (100101), m.a.w. de fout werd gecorrigeerd.

5.1.2 Bijzondere blokcodes Single parity check codes

De eenvoudigste codes voor foutcontrole zijn single parity check codes. Bij deze codes wordt één enkel bit toegevoegd aan het informatiewoord zodat de pariteit van het codewoord (d.i. het aantal keer '1' in het codewoord) steeds even (of oneven) is. In figuur 5.1 wordt een single parity check code getoond. De eerste bit van elk codewoord is de pariteitsbit. Dit pariteitsbit is zo gekozen dat de pariteit van het codewoord steeds even is. Het debiet voor een code met bloklengte n is gegeven door R, _ (n — 1)/n. Aan de ontvanger test men de pariteit van het ontv an gen woord door de modulo-2 som te nemen van alle codebits. Indien het resultaat van de modulo-2 som gelijk is aan 1, dan 106

pariteitsbit 0010 1 0

100111

codewoord

informatiewoord

100100

Figuur 5.1: Single parity check code weet de ontvanger dat het woord fouten bevat. Echter, de ontvanger kan de fouten niet corrigeren. De code k an slechts een oneven aantal bitfouten detecteren. Indien een even aantal bitfouten zou optreden, d an kan de ontvanger deze fouten niet detecteren. Dit geval stemt overeen met een niet-detecteerbare fout. Stel dat alle bitfouten even waarschijnlijk zijn en onafh an kelijk van elkaar voorkomen, dan kunnen we de probabiliteit dat j fouten voorkomen in een blok v an n bits schrijven als fl n) = ( )pi(i — p) n-j waarbij p de kan s is dat een bit foutief wordt ontvangen. Dit betekent dat voor een single parity check code de kans Pnd dat een fout niet gedetecteerd wordt gegeven is door de kans dat een even a antal fouten optreedt: 1n/2j

Pnd

=

^ 3= 1

n

j 2

p2j

(1 pr-2j

)

Voorbeeld: De (4, 3) even-pariteits single parity check code is gegeven in tabel 5.2. Deze code is in staat alle foutpatronen met 1 of 3 fouten te detecteren, maar niet de foutpatronen met 2 of 4 fouten. Indien p = 10-3 , dan is de kans dat een fout niet wordt gedetecteerd gegeven door Pnd

_

(

4)p2(1_p)2+ \4)p4

= 6p2 (1 — p)2 + p4 7p4 = 6p 2 — 12p3 + = 6(10 -3 ) 2 — 12(10 -3 ) 3 + 7(10-3 )4 6 x 10 -6 . De single parity check code wordt o.a. gebruikt wordt bij ASCII ((8, 7) single parity check code). In ASCII wordt een alfanumeriek karakter voorgesteld door een woord v an 10 bits, zoals getoond in figuur 5.2, waarbij de eerste en laatste bits de start en stop bits zijn die niet gebruikt worden voor foutcontrole, maar voor synchronisatie. De overige 8 bits besta an uit 7 informatiebits, waarmee men 128 karakters k an voorstellen, en een pariteitsbit die 1 of 0 is naargel an g de informatiebits en de gewenste pariteit. 107

Tabel 5.2: De (4, 3) even- pariteit single parity check code Informatiewoord Pariteit Codewoord

start bit

0000 1001 1010 1100 0011 0101 0110 1111

0 1 1 1 0 0 0 1

000 001 010 100 011 101 110 111

stop bit

(8,7) blokcode

7 informatiebits

ik

pariteitsbit Figuur 5.2: ASCII code Hammingcodes

De volgende vraag kan gesteld worden: hoe lang kunnen we een code maken voor een gegeven aantal pariteitsbits, en toch bekomen dat de minimale Hammingafstand van de code gelijk is aan 3. Aangezien alle sets van twee kolommen in de checkmatrix onafh ankelijk moeten zijn om een afst an d 3 te bekomen, is het voldoende te eisen dat alle kolommen in de checkmatrix verschillend moeten zijn van elkaar en van nul. Dit betekent, voor 3 pariteitsbits bestaan er 7 (= 23 — 1) verschillende vectoren die verschillend zijn van nul, voor 4 pariteitsbits bestaan er 15 (= 2 4 — 1) vectoren die verschillend zijn van nul, enz. Dit definieert een klasse v an codes waarbij (n, k) van de vorm (2p — 1, 2p — 1 — p) is, en waarbij p = n — k. Deze codes worden Hammingcodes genoemd. Voorbeeld 1: De checkmatrix van de (7, 4) Hammingcode is gegeven door 1 1 1 0 1 0 0 1 1 0 1 0 1 0 1 0 1 1 0 0 1

De kolommen van deze checkmatrix bestaan uit alle verschillende nietnulvectoren van lengte 3. 108

Hammingcodes hebben enkele unieke eigenschappen. Ten eerste, deze codes zijn een van de weinige bekende perfecte codes. Voor een perfecte code geldt de gelijkheid in de Hamminggrens: 2n-k

1

+ n.

Aangezien voor de Hammingcodes geldt dat n = 213-4 — 1, vinden we inderdaad dat deze codes perfect zijn. Een andere unieke eigenschap van Hammingcodes is dat deze codes één van de weinige codes zijn waarvan de gewichtsstructuur van de code a priori gekend is. De gewichtsfunctie voor een Hammingcode met minimumgewicht 3 en lengte n = 2' — 1 is gegeven door A °(x)

n+1

[(1 + x)n + n(1 + x) ( n -r) /2 (1 — x)(n+r)/2]

Hammingcodes met minimumgewicht 3 kunnen op een eenvoudige wijze omgevormd worden tot Hammingcodes met minimumgewicht 4, door één pariteitsbit toe te voegen die de som is van alle bits, inclusief de andere pariteitsbits. Deze bijkomende pariteitsbit zorgt ervoor dat de minimale Hammingafstand van de code 4 wordt. De kl as se van codes die men bekomt door een Hammingcode uit te breiden met een bijkomend pariteitsbit worden de uitgebreide Hammingcodes genoemd. De uitgebreide Hammingcodes zijn codes waarvoor (n, k) = (2P,2P — 1 — p). Voorbeeld 2: P as sen we deze procedure toe op de (7, 4) Hammingcode, dan is de checkmatrix voor de (8,4) uitgebreide Hammingcode gegeven door 1 1 1 0 1 0 1 1 0 1 0 1 H— _ 1 0 1 1 0 0 111111

0 0 0 1 01 1

De matrix linksboven in deze uitgebreide checkmatrix is de originele checkmatrix van de (7, 4) Hammingcode uit het vorige voorbeeld. Merk op dat de checkmatrix van de uitgebreide Hammingcode in het voorbeeld niet geschreven is in de systematische vorm: de rechterhelft van de matrix bestaat niet uit een eenheidsmatrix. Deze notatie laat ons niet toe de pariteitsbits te bepalen als functie van de informatiebits. Men kan echter de matrix in de systematische vorm krijgen door bij de vierde rij de eerste, tweede en derde rij op te tellen. In dat geval bekomen we de checkmatrix H=

1 1 1 0

1 1 0 1

1 0 1 1

0 1 1 1

109

1 0 0 0

0 1 0 0

0 0 1 0

0 0 0 1

Tabel 5.3: Basisvectoren van de Reed-Muller codes met n = 8 vo = (1 1 1 1 1 1 1 1) v1 =(0 0 0 0 1 1 1 1) v2=(0 0 1 1 0 0 1 1) v3 =(0 1 0 1 0 1 0 1) vj v2=(0 0 0 0 0 0 1 1) viva = (0 v2v3 = (0

0 0

0 0

0 1

0 0

1 0

0 0

viv2v3 = (0 0 0 0 0 0 0

1)

1) 1)

Reed-Muller codes

Reed-Muller codes worden als volgt gedefinieerd. Stel dat vo een vector is v an lengte 2' met allemaal enen. Noem v i , v2 , ... , vm de rijen van een matrix waarbij de kolommen bestaan uit alle mogelijke vectoren met m componenten. De rde orde Reed-Muller code heeft als basisvectoren de vectoren v o, v1 , v2 , ... , vm en alle vectoren die besta an uit de producten van 2 vectoren, 3 vectoren tot r vectoren uit de set v an vectoren v 1 , v2 , ... , v n . Het vectorproduct van twee vectoren a = (a1 , ... , an ) en b = (b1 , ... , bn ) definiëren we als ab = (aibi, . . . , anbn ). De rde orde Reed-Mullercode heeft voor gegeven in de volgende parameters: 7Z =

k dH,mi n

r)m

=

//

\\

m!

i =o = 2m-r.

Voorbeeld: In tabel 5.3 wordt de generatie van de Reed-Mullercodes gedemonstreerd voor n = 8. De generatormatrix van de eerste orde Reed-Mullercode bestaat uit de eerste vier basisvectoren vo , vl , v2 en v3. De tweede orde ReedMuller code wordt gevormd door aan de generatormatrix van de eerste orde Reed-Muller code de vectoren v 1 v2 , v1 v3 en v2v3 als rijen toe te voegen. De derde orde Reed-Mullercode wordt gevormd door de vector v 1 v2 v3 als rij toe te voegen.

Golay code

De Golay code is een van de meest belangrijke binaire blokcodes, aangezien deze code één van de weinige bekende niet-triviale perfecte codes is. De Golay code werd ontdekt toen

110

opgemerkt werd dat )

Co

+

+ (13 \)+

33) = 2 11 = 223-12, 2

wat het vermoeden deed rijzen naar het bestaan van een perfecte (23, 12) code waarvoor de Hamminggrens wordt bereikt. Men heeft inderdaad een perfecte (23,12) code gevonden: de Golay code. De generatormatrix van de (23,12) Golay code is gegeven door /1 0 1 0 1 0 1 0 1 0 0 0 1 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 G— 00000 00000 00000 00000 0 0 0 0 0 \0 0 0 0 0

0 0 1 1 1 0 1 0

0 0 0 1 1 1 0 1

1 0 0 0 1 1 1 0

1 1 0 1 0 1 0 0

1 1 1 0 1 0 1 0

0 1 1 1 0 1 0 1

0 0 0 0

0 0 0 0

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

1 1 0 0 0 1 1 1

0 1 1 0 0 0 1 1

0 0 1 1 0 0 0 1

0 0 0 1 1 0 0 0

0 0 0 0 1 1 0 0

0 0 0 0 0 1 1 0

0 0 0 0 0 0 1 1

0 0 0 0 0 0 0 1

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

0 0 0 0 0 0 0 0

0\ 0 0 0 0 0 0

0 0 0 0 1 1 0 0 0 1 0 0 0 1 1 0 0 1 1 0 0 0 1 1 0 1 1 1 0 0 0 1 1/

Deze code heeft een minimale Hammingafstand dx,min = 7, wat de grootste minimale Hammingafstand is voor alle gekende codes met dezelfde waarden voor n en k. Deze code is de enige (23,12) code die 3 fouten kan corrigeren. De bovenstaande generatormatrix is niet de enige mogelijke generatormatrix voor de (23, 12) Golay code. De volgende matrix definieert een andere (23, 12) Golay code, met dezelfde eigenschappen als de bovenstaande code: /1 1 0 0 0 1 1 1 0 1 0 1 1 0 0 0 1 1 1 0 0 0 1 1 0 0 0 1 1 1 0 0 0 1 1 0 0 0 1 1 0 0 0 0 1 1 0 0 0 1 0 0 0 0 0 1 1 0 0 0 G= 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 \0 0 0 0 0 0 0 0 0 0

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

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

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

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

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

0 0 0 0 0 0 0 0\ 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 1 0 1 0 0 0 0 1 0 1 0 1 0 0 0 1 1 0 1 0 1 0 0 1 1 1 0 1 0 1 0 0 1 1 1 0 1 0 1/

De Golay code kan uitgebreid worden tot een (24, 12) code met minimale Hammingafstand dx min = 8 door één pariteitsbit toe te voegen op het einde van elk woord, zodat elk ,

111

codewoord een even pariteit heeft. Het voordeel van deze uitgebreide Golay code is dat het debiet van de code R, = 1/2, zodat deze eenvoudig te gebruiken is. In deze uitgebreide Golay code heeft elk codewoord een gewicht dat een veelvoud is van 4. De uitgebreide code is geen perfecte code, maar een quasi-perfecte code: de grootste afstand tussen een vector en een codewoord is ten hoogste gelijk aan t + 1. LDPC codes Low-density parity check (LDPC) codes zijn lineaire blokcodes waarvan de checkmatrix zeer weinig enen bevat. Er kan aangetoond worden dat deze codes asymptotisch goed zijn, m.a.w. het is theoretisch mogelijk met deze codes de kanaalcapaciteit (Shannonlimiet) te bereiken als de bloklengte n van de code naar oneindig gaat. Het feit dat een code asymptotisch goed is betekent nog niet dat deze performantie gehaald kan worden met praktische decodeertechnieken. Echter, voor LDPC codes werd een aantal jaren geleden een iteratief decodeeralgoritme voorgesteld, waarmee men de kanaalcapaciteit kan benaderen: voor lange bloklengtes is aangetoond dat in de praktijk de kanaalcapaciteit kan benaderd worden tot op een fractie van een dB. Er bestaan reguliere en irreguliere LDPC codes. Bij een reguliere LDPC code bevat elke rij en elke kolom van de checkmatrix een vast (klein) aantal enen, terwijl bij een irreguliere code het aantal enen per rij en per kolom variabel is. Een eenvoudige manier om een reguliere LDPC code te genereren werd voorgesteld door Gallager. In deze methode definieert men e als het aantal enen per rij en j als het aantal enen per kolom. Om de checkmatrix te construeren gebruiken men een p x p matrix A (p is een priemgetal), die bestaat uit een linkse of rechtse cyclische verschuiving van de p x p eenheidsmatrix: 0 0 0 0 1

/0 0 0 0 1

A=

10000 01000 00 100 0 0 '0 1 0

1 0 0 0 0

0 1 0 0 0

0 0 1 0 0

0 0 0 1 0

rechtse cyclische verschuiving

linkse cyclische verschuiving

De checkmatrix H wordt dan geconstrueerd als:

H=

/I I

I A

••• ...

AE -1

\ I Ai -1 ... AV - 1 )(j -1 )

)

waarbij I de p xp eenheidsmatrix is en A` de ide macht is van de matrix A. De resulterende checkmatrix is een pj x pE matrix. Hieruit volgt dat de lengte van een codewoord gegeven is door n = pt. Wanneer men de checkmatrix beter bestudeert, dan zien we dat voor deze constructie j - 1 rijen lineair afhanke lijk zijn van de andere rijen. Hieruit volgt dat de 112

(a) harde decodering bitsequentie 10,1 }

c

—^

symbolen omzetting {-1 ,± 1 } bits naar symbolen ^

kanaal y1=xi+w

decoder

^

ruis quantisator met 2 niveaus

(b) zachte decodering bitsequentie {0 , 1} c

—^

kanaal omzetting bits naar symbolen

>Q w^ ruis

yï xi +Wi

decoder

Figuur 5.3: Schema van de zender en ontv an ger voor zachte en harde decodering lengte van het informatiewoord voor deze codes gegeven is door k = p(Q — j) + j — 1. De minimale Hammingafstand voor deze constructie is naar beneden begrensd: dH,mán

> 2j.

Op deze manier kan men op een eenvoudige man ier een code construeren met de gewenst minimale Hammingafstand. Uit de praktijk volgt dat irreguliere LDPC codes typisch een betere performantie hebben dan reguliere LDPC codes.

5.2 Performantie van codes Met de performantie van een lineaire blokcode bedoelen we de kans dat een codewoord foutief wordt gedecodeerd. Zoals in dit hoofdstuk werd a an getoond, zal de performantie verschillen naargelang de code wordt gedecodeerd met behulp van een harde of zachte decoder. In deze sectie bepalen we de performantie voor harde en zachte decoders. Tevens wordt de bitfoutprobabiliteit (d.i. de k an s dat een informatiebit foutief wordt ontvangen) bepaald, wat een belangrijke parameter is bij het ontwerp van praktische communicatiesystemen.

5.2.1 Performantie van harde decoders Eerst bepalen we de performantie van een harde decoder. Hierbij veronderstellen we dat de gecodeerde bits worden verstuurd over het fysische kanaal zoals getoond in figuur 5.3(a). 113

De sequentie c van n gecodeerde bits wordt eerst één na één omgezet in een sequentie x van binaire symbolen, waarbij Xi

+l = Eb {_ i ^

als ci. =1 als ci. =0

i= 1,2,...,n,

waarbij Eb,c de energie verstuurd per codebit voorstelt, m.a.w. we gebruiken antipodale signalen. We definiëren de energie die per informatiebit wordt verstuurd als Eb = Eb, c /R c , k/n het codedebiet is. De sequentie x van binaire symbolen wordt dan warbijR,= verstuurd over het fysische kanaal, dat gemodelleerd wordt als een geheugenloos kanaal met een discrete ingang en een continue uitgang. Het kanaal voegt witte Gaussiaanse ruis wi toe aan de symbolen; de ruis heeft gemiddelde nul en variantie N 0 /2, en de ruis op verschillende tijdstippen is statistisch onafhankelijk. De uitgang van het kanaal is dan yi= x: +

w^ .

Gebaseerd op de ontvangen sequentie y wordt een beslissing genomen over de verstuurde codebits c. In een harde decoder gebeurt dit door de ontvangen sequentie y eerst te quantiseren met 2 niveaus. De gequantiseerde sequentie r is gegeven door

ri =

1 als yi >0 0 als yi < 0

i =1,2,...,n.

Deze sequentie r kan geschreven worden als het verstuurde codewoord c en een foutvector e, die verschilt van nul in de posities waar het kanaal een fout heeft geïntroduceerd. De decoder tracht het verstuurde codewoord te vinden door de fouten in de sequentie r te corrigeren. Merk op dat het beschouwde kanaal in figuur 5.3(a) equivalent is met het binair symmetrisch kanaal in figuur 5.4, waarbij de overgangsprobabiliteit p gegeven is door (zie het voorbeeld in sectie 4.3.1)

(V2

(5.12)

Exacte decodeerfoutprobabiliteit De decoder zoekt het codewoord dat het dichtst bij de ontvangen sequentie r ligt: c = arg min dH (r, c).

(5.13)

Uit de decodeertabel kan men voor a lle mogelijke ontvangen sequenties r aflezen wat het dichtstbijzijnde codewoord is. Aangezien de code lineair is, kan men ook de syndroomtabel gebruiken om de decodeerfoutprobabiliteit te bepalen. Immers, indien een foutvector

114

C1

omzetting bits naar symbolen

symbolen- kanaal x.

ruis (a)

c^

r^

0

0

1

Figuur 5.4: Equivalent kanaal voor harde decodering voorkomt in de syndroomtabel, is de fout corrigeerbaar, terwijl als een foutvector niet aanwezig is in de syndroomtabel, een decodeerfout optreedt. Aangezien het binair symmetrisch kanaal, dat gebruikt wordt voor harde decodering, geheugenloos is, zijn de bitfouten onafhankelijk van elkaar. Hieruit volgt dat de kans Ps,e op een decodeerfout geschreven kan worden als: Ps,e = P{e niet in syndroomtabel} n

=

EAxpx(1 - p) n-x

(5.14)

x= 1

waarbij px (1 - p) n-x de kans is dat het gewicht v an de beschouwde foutvector x is, p gegeven is door (5.12), en As het aantal foutvectoren is met gewicht x die niet voorkomen in de syndroomtabel. Dit aantal is naar boven begrensd door het maximaal a antal foutvectoren met gewicht x, nl. (n): A x < (:). Hieruit volgt dat in de syndroomtabel Ax foutvectoren met gewicht x aanwezig zijn, en dus aanleiding geven tot een correcte decisie. De grootte van de syndroomtabel stijgt exponentieel met n - k. Indien n - k, dus het aantal pariteitsbits, groot is, dan wordt het bepalen van As moeilijk. Daarom zal men in de praktijk in veel gevallen niet de exacte decodeerfoutprobabiliteit bepalen, maar wel een eenvoudige bovengrens.

(x) —

Foutdetecterend en foutcorrigerend vermogen

Uit de decisieregel (5.13) volgt dat, indien codewoord c i werd verstuurd, de decoder het codewoord juist zal decoderen indien dH(r, ci ) < dH(r, ci ) `di 4 j. Noemen we dH,min de ,

115

minimale Hammingafstand tussen de codewoorden dx(ci, ci ), (5.15) dx,min = Vi,min j;i0j dan zal de decoder zeker een juiste beslissing nemen indien het aantal bitfouten in een codewoord kleiner is dan de helft van de minimale Hammingafstand van de code. Dit betekent, opdat zeker een correcte beslissing zou genomen worden, dat het a antal fouten kleiner dan of gelijk aan t moet zijn, met t gegeven door: (5.16)

t = L Z (dx , min — 1) j .

Om het foutdetecterend en foutcorrigerend vermogen van een code te bestuderen kan men elk codewoord voorstellen als een punt in de n-dimensionale ruimte. Indien elke codewoord beschouwd wordt als het middelpunt v an een bol met straal t, dan is de grootste waarde van t waarvoor de verschillende bollen elkaar niet snijden gegeven door t = 12 (dx,min — 1) j. De vectoren binnen elke bol liggen op een afstand kleiner d an of gelijk aan t van het codewoord in het middelpunt van de bol. Elke vector binnen deze bol zal dus gedecodeerd worden als het codewoord in het middelpunt v an de bol. Dit betekent dat de code met minimale Hammingafstand dx,min in staat is t = Lz(dx min-1)j fouten te corrigeren. Figuur 5.5 geeft een tweedimensionale voorstelling van de codewoorden en de bollen. Verder, aangezien de afstand tussen twee codewoorden minimaal dx,min is, is het mogelijk dat een foutpatroon met dH,min fouten een codewoord omzet in een ander codewoord. Dit noemt men een nietdetecteerbare fout. Echter, indien het aantal fouten kleiner is dan dx,min, dan zal de decoder steeds de aanwezigheid detecteren van één of meerdere fouten. Hieruit volgt dat een code met minimale Hammingafstand dx,min steeds in staat is dx,min — 1 fouten te detecteren. Zoals hierboven wordt vermeld kan een code met minimale Hammingafstand dx,min worden gebruikt om dx,min — 1 fouten te detecteren of t = LZ (dx,min — 1)] fouten te corrigeren. Het is duidelijk dat om t fouten te kunnen corrigeren we t fouten moeten kunnen detecteren. Echter, het is mogelijk om meer d an t fouten te detecteren indien we een compromis sluiten tussen het foutcorrigerend vermogen en het foutdetecterend vermogen. Bijvoorbeeld, een code met minimale Hammingafstand dH ,nin = 7 kan t = 3 fouten corrigeren. Indien we 4 fouten wensen te detecteren kunnen we dit doen door de straal van de bol rond de codewoorden te verminderen van 3 naar 2. In dat geval zijn foutpatronen met 4 fouten detecteerbaar, maar enkel foutpatronen met 2 fouten kunnen gecorrigeerd worden. Dit betekent dat wanneer 2 fouten optreden men deze kan corrigeren, en wanneer 3 of 4 fouten optreden, men kan vragen voor retransmissie. Indien meer dat 4 fouten optreden zullen deze fouten niet gedetecteerd kunnen worden w anneer ze in een van de bollen met straal 2 rond een codewoord vallen. Analoog kan men met dx min = 7 vijf fouten detecteren en één fout corrigeren. In het algemeen zal een code met minimale Hammingafstand dH,mtn ed fouten kunnen detecteren en e, fouten kunnen corrigeren, waarbij ,

,

e, + ed < dxmin — 1,

en e, < ed.

116

•

Figuur 5.5: Voorstelling van codewoorden als middelpunt van een bol met straal t = L (aH,min — 1 )^

z

Bovengrens decodeerfoutprpbabiliteit

Merk op dat de tweede voorwaarde (aantal fouten < t) strenger is dan de eerste voorwaarde (dH (r, cj) < dH(r, ci), Vi j). Deze tweede voorwaarde zal dus leiden tot een bovengrens voor de kans dat een codewoord fout wordt gedecodeerd. De kans dat m bitfouten optreden in een blok van n bits igegevenep door P(m, n)

= ( fl )(l

— p)n

,n,

(5.17)

waarbij p is gegeven is door (5.12). Hieruit volgt dat de kans PS dat een codewoord foutief wordt gedecodeerd, naar boven begrensd is door n

Ps <

E

(5.18)

P(m, n). m--t+1

Indien p klein is wordt de som in (5.18) bepaald door de term met m = t + 1, m.a.w. Ps P(t + 1,n) = ( n

t+

117

)t ^ l(i

pr-t-1.

(5.19)

1.E+00 1.E-01 1.E-02 1.E-03 1.E-04 1.E-05 exact, (7,4) Hamming bovengrens, (7,4) Hamming -e- exact, (8,4) Reed-Muller bovengrens, (8,4) Reed-Muller

—Bi-

1.E-06 -

--

1.E-07 0 1' 2 3 4 5 6 7 8 9 10 11 12 Eb/• O ( dB ) Figuur 5.6: Decodeerfoutprobabiliteit voor harde decodering: exact en bovengrens. Rekening houdend met de definitie (5.16), volgt hieruit dat de kans dat een codewoord foutief wordt gedecodeerd bepaald wordt door de minimale Hammingafstand van de code. Een bovengrens voor de bitfoutprobabiliteit Pb van de code kunnen we vinden via de pessimistische veronderstelling dat een foutpatroon met in fouten (m > t) ervoor zorgt dat het gedecodeerde woord verschilt van het verstuurde codewoord in m + t posities. In het ergste geval bevinden deze m + t fouten zich in het informatiegedeelte van het het codewoord, zodat een fractie (m + t)/k informatiebits foutief gedecodeerd wordt: Pb

<

Ê

m, =t+i

777,

k

P(m, n).

(5.20)

In figuur 5.6 wordt de exacte decodeerfoutprobabiliteit (5.14) en de bovengrens (5.18) getoond voor harde decodering, voor de (7,4) Hammingcode en de (8,4) Reed-Muller code uit tabel 5.3, als functie van Eb/No (dB), de signaal-ruisverhouding per informatiebit. Uit deze figuur volgt dat de bovengrens een goede benadering is voor de exacte decodeerfout118

Tabel 5.4: Lijst van codes gebruikt in figuur 5.7 ACG (dB) ACG (dB) Code n k dx,min R hard zacht Hamming 7 4 3 4/7 0.6 2.3 Reed-Muller 8 4 4 1/2 0 3 Golay 23 12 7 12/23 3.2 5.6 probabiliteit. In het algemeen blijkt deze bovengrens een goede benadering te vormen voor de exacte decodeerfoutprobabiliteit Ps . In figuur 5.7 wordt de bovengrens voor de bitfoutprobabiliteit (5.20) weergegeven voor de codes in tabel 5.4. In de figuur is ook de bitfoutprobabiliteit voor ongecodeerde transmissie weergegeven. Uit de figuur volgt dat voor lage Eb/No de codes niet goed werken: bij lage Eb/No is het aantal fouten geïntroduceerd door het kanaal te groot. De code kan deze fouten niet corrigeren, zodat het codewoord foutief wordt gedecodeerd, waardoor na decoderen een groter aantal informatiebits foutief is dan in het geval waarbij de bits niet gecodeerd zijn. Bij grote Eb/No is p klein, zodat het a antal fouten in een codewoord klein is. In dit geval zal de code wel de fouten kunnen corrigeren, zodat de code een betere performantie zal hebben d an in het ongecodeerde geval. Aangezien p in dit geval klein is, zal in (5.20) de term met m = t + 1 dominant zijn. Hieruit volgt dat de bitfoutprobabiliteit bij grote Eb/No bepaald wordt door de minimale Hammingafstand dx,mrn van de code. Uit de figuur volgt inderdaad dat de bitfoutprobabiliteit afneemt als de minimale Hammingafstand van de code stijgt. De afstand, bij gegeven Pb, tussen de curve voor ongecodeerde en gecodeerde transmissie wordt de netto codewinst genoemd: dit is de winst in Eb/No die men bekomt door de informatiebits te coderen. Merk op dat bij Pb = 10-7 , de Reed-Muller code nog geen codewinst oplevert. Dit is te wijten aan de combinatie van het lage codedebiet (R c = 1/2) en het laag foutcorrigerend vermogen van de code (t = 1). 5.2.2

Performantie van zachte decoders

Om de kans op een decodeerfout in het geval van zachte decodering te bepalen, maken we gebruik van hetzelfde communicatiesysteem als voor harde decodering (zie figuur 5.3(b)). Echter, het verschil is dat bij zachte decodering de uitgang van het kanaal niet gequantiseerd wordt. Bij zachte decodering wordt de sequentie y gebruikt om een beslissing te nemen over het verstuurde codewoord. De decoder kiest het codewoord c, overeenkomend met de sequentie x die op de kleinste Euclidische afstand ligt van de ontvangen sequentie y:

c = arg min d2 (y,x(c)).

(5.21)

Het gevolg is dat met zachte decodering men soms in staat is om foutpatronen met meer dan t = LZ(dH ,nan — 1)] fouten te corrigeren. ,

119

Ongecodeerd —$— Hamming, hard

1.E+00

—

1

0

—

a

—

—

Reed Muller, hard -

Golay, hard

• • l• • Hamming, zacht - - e- Reed-Muller, zacht • •o• •

Golay, zacht

1.E-03

1.E-04

-06

3

4 5 6 7

Figuur 5.7: Bitfoutprobabiliteit voor harde en zachte decodering van de codes in tabel 5.4. Exacte decodeerfoutprobabiliteit

De kans dat een codewoord foutief wordt gedecodeerd is gelijk aan 2k

2k

Pr(ci Ici )Pr(ci ), Pr(ci|ci)Pr(ci), E E j=1 i=1,Joi

(5.22)

waarbij Pr(ci Ici |ci)) de kans is dat het codewoord 6.1 wordt gekozen als het codewoord c i i is verstuurd. Veronderstell wasvertud,nP(q)kasithecodwr rden, even waarschijnlijk zijn, dan geldt nformatiewoorden, dus ook alle cod Pr(q) = 1/2 k , i = 1, 2, ... , 2k. Een bovengrens voor Ps wordt bekomen door gebruik te maken van de 'union bound' benadering: Pr(c,|ci) Pr(c,Ici)

Pr( Upkl,l d2 (y,xi) S d2(y,xt)Ici) Pr(Upk l,toj ojd2(y,xi) d2(y,xl)|ci) Pr(d2 (y,xi) 5 d2 d2(y,xi)|c (y,xi)Ic ), 120

(5.23)

waarbij xi de binaire sequentie is die overeenstemt met het codewoord c i , zodat 2k

P8 <

2k

2k

E E Pr(d2(M, xj) < d2 (Y, Xj)jci).

(5.24)

i=1 j=1,j¢i

De Euclidische afstand tussen twee sequenties kan geschreven worden als volgt: d2 (a, b)

=a

— b02 = (a — b) T (a — b),

(5.25)

i=1 zodat de kans Pr(d2 (y, xj ) < Pr(d2 (Y, xj)

c(y, xi )ici )

zich herleidt tot

< d2 (Y, xi)Ici) = Pr(y T (xi

—

xj ) <

x2 ( i xi — xT xj ) |ei ).

(5.26)

Hernoemen we de scalaire grootheid y T (xi — xj) = u. Indien het codewoord c i verstuurd werd, dan is de ontvangen sequentie y Gaussiaans verdeeld met gemiddelde x i en covariantiematrix No/2In , waarbij In de n x n eenheidsmatrix voorstelt: p(Y =

e-NO(y-x0T(y-X,) 1 (iNo) n/2

Hieruit volgt dat u ook Gaussiaans verdeeld is met gemiddelde m u en variantie o : mu = x T(xi — xj ) Uu 2

=

-(x

— xi ) T (Xi — xi) — a kxi,

xi).

De kans (5.26) kan nu herschreven worden als i:Tx,-xTx; )

|ci) Pr(d2 (Y, xj) < d2 (y, xi) lci)

1

27fUu e ^ a —

Q

j)

2

(1

No 2(,,x

\

(5.27) '

waarbij

j

Q(x) =

(5.28)

00

de complementaire errorfunctie is. Deze functie wordt getoond in figuur 4.6. In het beschouwde communicatiesysteem, waarbij de bits worden omgezet in binaire symbolen, bestaat er een eenvoudig verband tussen de Hammingafstand d H (ci, cj ) tussen de codewoorden ci en cj en de ',Euclidische afstand d 2 (xi , xj ) tussen de corresponderende xi en xj : binaire sequen

d2(xi ,xj ) = 4R,EbdH (ci ,cj ), 121

(5.29)

met Rc = k/n het codedebiet en

de energie verstuurd per informatiebit, zodat

Eb

2k

2k

P8 < 2k

E Q(V2Re

i=1 1=1,3 02,

o

d„(cci i, )) •

(5.30)

Uit de lineariteit van de code volgt dat d x (ci , cl ) = dx (ci - c„ 0), waarbij c i - cj ook een codewoord is. Hierdoor kan de dubbele sommatie in (5.30) herleid worden tot een enkele sommatie: 2k

N dx(ci O) ,

E

Ps

3

i =2

(5.31)

waarbij er verondersteld werd dat c 1 = 0 = (0, 0, ... , 0) het nulwoord is. We definiëren de ingangs-uitgangsgewichtsfunctie A I,o(x, z) van een code als n

A'I ,O(x,

z)

-

k

E E Ad,wxdzw,

(5.32)

d=0 w=0

waarbij Ad,,,, het aantal codewoorden is met een informatiegewicht w die aanleiding geven tot een codewoord met gewicht d. Het verband met de uitgangsgewichtsfunctie (5.4) is gegeven door Ao(x) = A I,o(x,1 1). Rekening houdend met (5.32) kan (5.31) herschreven worden als

5

Ps

E AdQ /2RC #d) d =dxm[n

(5.33)

(

waarbij Ad = Ew=1 Ad,w het aantal codewoorden is met gewicht d. De bovengrens (5.33) is een goede benadering voor de kans op een decodeerfout wanneer Eb/No voldoende groot is (het verschil tussen de bovengrens en de werkelijke kans op een decodeerfout is zeer klein wanneer Ps < 10-3 ). Voor grote waarden van Eb/No wordt de som in (5.33) gedomineerd door de term waarvoor d = dx,min, zodat (5.33) kan benaderd worden door Eb

AminQ

,

(5.34)

0

waarbij Amin het aantal codewoorden voorstelt met minimaal Hamminggewicht. Op een analoge manier als voor de kans op een decodeerfout kan men een bovengrens vinden voor de bitfoutprobabiliteit: 2k

^

Pb < E dx ( a, 0 2

)

Q (

/2R C

dH(Cio) )

(5.35)

waarbij bi het informatiewoord is dat overeenstemt met het codewoord c i . Gebruik makend van de gewichtsstructuur A(w, cd) van de code kan de bitfoutprobabiliteit (5.35) herschreven 122

worden als Pb

<

E

d=dmin

waarbij

AdQ ( V2RC-zo d)

_ Ad =

1

(5.36)

k E Adw

(5.37)

k v,=1

het gemiddelde gewicht is van de informatiewoorden die omgezet worden in codewoorden met gewicht d. Bovengrens decodeerfoutprobabiliteit

Uit (5.33) en (5.36) volgt dat indien de gewichtsstructuur van de code gekend is, men de performantie van de code kent. In de praktijk zal het bepalen van de gewichtsstructuur voor codes met grote bloklengte n of grote informatielengte k zeer rekenintensief zijn. Een eenvoudige bovengrens voor de kans op een decodeerfout kan op een analoge m an ier worden bekomen als bij harde decodering. Bij harde decodering zal de ontvanger gegarandeerd een correcte beslissing nemen indien de Hammingasequentiesen het verstuurde codewoord en de ontvangen se gquentie, m.a.w. het Hamminggewicht van de foutvector, kleiner dan of gelijk aan t = L H, 2n -1 ^ is. Bij zachte decodering kan dit vertaald worden naar het volgende: indien de Euclidische afst an d tussen de verstuurde sequentie x(c) en de ontvangen sequentie y kleiner is dan d(y,x(c)) < á V4R.cEbdH,min (zie (5.29)), d an zal de orwaarde strenger is dan de decoder zeker juist decoderen. Merk op dat deze t 2 (y,x3 ) RcE6dH,minl RcE6dH,min| c = 0} ,

,

o ) > 2Rc Nó dH, min lc = 0 } . (5.38) No y — xo) T (Y — x JJ t met het nulwoord. De toewaarbij xo de sequentie van symbolen is die correspo valsgrootheid ri(y —xo)|c xo)Ic = 0 is Gaussiaans verdeeld met gemiddelde 0 en de covariantiematrix is de eenheidsmatrix. Definiëren we u als P

-

{

(5.39)

u = No (y — xo) T (Y — xo)Ic = 0,

dan is u x2 (n) verdeeld met ri vrijheidsgraden. Hieruit volgt dat de bovengrens op de decodeerfoutprobabiliteit te schrijven is als „

„ Í_ _

n

Eb d ^

No

L

+00

H, min

Eá

E

ó UHmi n

123

r

2r(

(xl a-1 l)

n

2

2

dx

(5.40)

1.E+00

Kans op decodeerfout PS

1.E-01 1.E-02 1.E-03 1.E-04 1.E-05 1.E-06 -

-B- exact, (7,4) Hamming -6+ bovengrens, (7,4) Hamming -e- exact, (8,4) Reed-Muller -*- bovengrens, (8,4) Reed-Muller

1.E-07 3 4 5 6 7 8 9 10 11 12

0

Eb/No ( dB )

Figuur 5.8: Decodeerfoutprobabiliteit voor zachte decodering: exact en bovengrens. Voor grote waarden v an Eb/No kan men aantonen dat de bovengrens op de decodeerfoutprobabiliteit evenredig zal zijn met: ps

E ^

—Rc N dH.min

Eb groot.

No

,

(5.41)

In figuur 5.8 wordt de exacte decodeerfoutprobabiliteit (5.34) en de bovengrens (5.40) getoond voor zachte decodering, voor de (7,4) Hammingcode en de (8,4) Reed-Muller code uit tabel 5.3, als functie van E b/No . In tegenstelling tot harde decodering, waar de bovengrens een goede benadering vormt voor de exacte decodeerfoutprobabiliteit, leiden we af uit de figuur dat de bovengrens (5.40) de exacte decodeerfoutprobabiliteit slecht benadert. Slechts bij zeer grote waarden van de signaal-ruisverhouding, dus bij zeer lage decodeerfoutprobabiliteit, zal de bovengrens naar de exacte decodeerfoutprobabiliteit convergeren. In figuur 5.7 is tevens de bovengrens voor de bitfoutprobabiliteit (5.35) voor zachte decodering getoond voor de codes uit tabel 5.4. Bij kleine Eb/No zal zachte decodering een 124

slechter resultaat geven dan niet-gecodeerde transmissie, net zoals harde decodering. Voor grote Eb/No wordt de som (5.36) gedomineerd door de codewoorden op minimale Hammingafstand. Dit volgt ook uit de figuur: de netto codewinst is groter wanneer de minimale Hammingafstand toeneemt. Verder merken we op dat de performantie van een zachte decoder steeds beter is dan die van een harde decoder. Echter, dit betekent niet dat harde decoders niet worden gebruikt in de praktijk, aangezien de implementatiecomplexiteit van harde decoders heel wat lager is dan van zachte decoders.

5.2.3 Vergelijking van de performantie van harde en zachte decoders Wanneer de signaal-ruisverhouding Eb/No toeneemt, dan is de bitfoutprobabiliteit van harde (5.20) en zachte (5.36) decoders bepaald door de eerste term in de sommatie, dus door de minimale Hammingafstand dH,min van de code. Bij grote Eb/No herleidt de bitfoutprobabiliteit voor harde decodering zich dus tot: Pb,H

^

+1

n 1 k t C +1 2t

J

Q

(

J2REb No ^

c+1

)]

(5.42)

en voor zachte decodering

Pb,Z'

AminQ

l Eb V 2RcNo dH min ,

(5.43)

waarbij Amin het gemiddelde gewicht is v an de informatiewoorden die omgezet worden in codewoorden met gewicht dH,min• We vergelijken deze bitfoutprobabiliteiten met de bitfoutprobabiliteit van ongecodeerde transmissie: (5.44)

1 /2N VVVV o

Pb,U = Q

Bij deze vergelijking maken we gebruik v an een bovengrens voor de Q-functie (zie ook figuur 4.6): Q(x) <

Ze-

(5.45)

.

Indien we de Q-functies in (5.42), (5.43) en (5.44) verv an gen door hun exponentiële bovengrens (5.45), dan bekomen we de limieten lira ln Pb,H = —(t

ó -4.O°

lim in Pb,Z ó^^

lixn

ó -4°°

Eb

+ 1)R` No Eb

p = — dH,minRcN 0

Eb

No

In Pb,u 125

•

(5.46)

Vergelijken we de limiet voor ongecodeerde transmissie met de limieten voor harde en zachte decodering, dan zien we een voorfactor (t +1)1i, (bij harde decodering) en dH,minRc (bij zachte decodering). Deze factor (uitgedrukt in dB) noemt men de asymptotische codewinst (ACG), a angezien doze factor de relatieve winst aan energie voorstelt bij hoge signaal-ruisverhoudingen (waar de voorfactoren in (5.42) en (5.43) geen rol meer spelen) door het coderen van de informatie. Vergelijken we de asymptotische codewinst van harde en zachte decodering, dan bekomen we in de limiet RQdH ,min lim 2 (5.47) dH,min-coR c (t + 1) Hieruit kunnen we halen dat, bij hoge Eb/No en bij codes met voldoende grote minimale Hammingafstand, er bij harde decodering een efficiëntieverlies van 10 log10 2 = 3 dB optreedt ten opzichte van zachte decodering, m.a.w. Eb/No moet 3 dB hoger zijn bij harde decodering om dezelfde bitfoutprobabiliteit te bekomen als bij zachte decodering. In de praktijk zal dit verschil in efficiëntie iets kleiner zijn, wegens de aanwezigheid van de voorfactoren in (5.42) en (5.43), en het feit dat ,m in < 2(t + 1). De netto codewinst zal steeds kleiner zijn dan de asymptotische codewinst: de asymptotische codewinst is een bovengrens voor de netto codewinst. In tabel 5.4 is voor de codes eveneens de asymptotische codewinst weergegeven voor harde en zachte decodering. Vergelijken we deze waarden met de nettowinst bij Pb = 10-7 infgur5.7,dazewtnocdiseraklndsymptoiche codewinst, maar dat beide van dezelfde grootteorde zijn. Merk ook op dat bij harde decodering van de Reed-Muller code geen asymptotische codewinst wordt bekomen, wat men ook kan observeren in figuur 5.7: de winst gegenereerd door het verhogen van de minimale Hammingafstand wordt teniet gedaan door het lage codedebiet.

5.3 Grenzen voor de minimale afstand van codes We hebben aangetoond in de vorige sectie dat de performantie van een code wordt bepaald door de minimale Hammingafstand van de code. In deze sectie bepalen we enkele bovenen ondergrenzen voor de minimale Hammingafstand v an lineaire blokcodes, die men dan kan gebruiken om boven- en ondergrenzen te bepalen voor de performantie van een code. In de beschrijving van de boven- en ondergrenzen voor de minimale Hammingafstand beschouwen we het geval v an een (n, k) binaire code. In dit geval wordt een informatiewoord b bestaande uit k bits in de encoder omgezet in een codewoord c met n bits. Dit betekent dat het aantal informatiewoorden, dus het aantal codewoorden gegeven is door L = 2k . Voor lineaire codes kan men de volgende grenzen voor de minimale Hammingafstand dH,min bepalen.

126

5.3.1

Hamminggrens

De Hamminggrens is een bovengrens voor de minimale Hammingafstand van de code, en wordt ook wel de 'sphere packing bound' genoemd. Om de Hamminggrens af te leiden visualiseren we de codewoorden als punten in een n-dimensionale ruimte. We beschouwen een bol met straal t rond elk codewoord zoals getoond in figuur 5.5, waarbij elke vector die binnen deze bol ligt gedecodeerd wordt als het codewoord in het middelpunt v an de bol. In de vorige sectie hebben we aangetoond dat de grootste waarde v an t, zodat de bollen elkaar niet snijden, bepaald wordt door de minimale Hammingafstand dH, min van de code, nl. t = L2(dH,min — 1) J. Elke bol bevat de vectoren op een afstand kleiner dan of gelijk a an t van het codewoord in het middelpunt v an de bol. Het a an tal vectoren in een bol met straal t is gegeven door 1+(i)+(2)+ ...+ (t) =

(n)

(5.48)

Aangezien er L = 2k codewoorden zijn, bestaan er 2k niet-overlappende bollen die elk een straal t hebben. Het aantal veetoren die binnen deze 2 k bollen liggen kan niet groter zijn dan de 2° mogelijke vectoren van lengte n. Hieruit volgt dat de t-foutencorrigerende code moet voldoen aan de ongelijkheid

2k E

n

( Z) <2

(5.49)

of, t

(5.50)

2n-k > (n) .

Hieruit volgt dat er een ondergrens bestaat voor het codedebiet R, van een tfoutencorrigerende code met lengte n: 1—

n log2 E

( ni ).

(5.51)

De gelijkheid in (5.50) is voldaan voor een perfecte code. Een perfecte code heeft de eigenschap dat alle bollen met straal t elkaar niet raken, en dat alle mogelijke vectoren van lengte n in één van de bollen zit. Dit betekent dat elke mogelijke vector van lengte n ten hoogste op een afstand t van één v an de mogelijke codewoorden zit. Voor een perfecte code kunnen alle foutpatronen tot t fouten gecorrigeerd worden. Anderzijds, elk foutpatroon met meer dan t fouten k an niet gecorrigeerd worden. Hieruit volgt dat voor een perfecte code de bovengrens in (5.18) bereikt wordt. Naast perfecte codes bestaan ook heel veel quasi-perfecte codes. Een tfoutencorrigerende code wordt quasi-perfect genoemd indien alle bollen met straal t en 127

als middelpunt een codewoord, elkaar niet snijden, en indien alle andere punten in de ndimensionale ruimte op een afstand van ten hoogste t + 1 liggen van een codewoord. Dit betekent dat in een decodeertalbel, de lijst met coset-leiders alle foutpatronen tot t fouten bevat, een aantal patronen met t + 1 fouten, maar geen enkel patroon met meer fouten. Deze manier van coderen levert', ons een code op die beste performantie heeft voor gegeven n en k. Een voorbeeld van een iquasi-perfecte code is de (6,3) code uit tabel 5.1. 5.3.2 Singletongrens De Singletongrens is een bovengrens voor de minimale Hammingafstand van de code die zeer eenvoudig te bewijzen is voor lineaire codes, maar zeer moeilijk te bereiken is in de praktijk. Hierbij merken we op dat voor lineaire codes de minimale Hammingafstand gelijk is aan het minimale Hamminggewicht van een codewoord. Het Hamminggewicht van een codewoord is gelijk aan het aantal posities waarin het codewoord verschilt van nul: n dH(x) = > xi.

i=1

(5.52)

Een codewoord dat verschilt van nul heeft ten minste 1 informatiebit van de k mogelijke informatiesymbolen dat verschilt van nul, en het grootste gewicht van de andere n — k redundante bits is duidelijk '', n — k. Dit betekent dat het minimale gewicht van een codewoord, dus dH,min, niet groter kan zijn dan n — k + 1. dH,min


(5.53)

Codes die deze bovengrens bereiken noemt men maximum distance separable (MDS).

Een belangrijke implicatie van de Singletongrens wordt gegeven door de minimale Hammingafstand te delen door de codelengte n: 1 dH,„" < n— k +1 = 1 — + —. n' n n

(5.54)

Voor lange codes (n » 1) vinden we dat dH,,,,,in/n kleiner moet zijn d an 1 — Rc . Indien we opmerken dat het gegarandeerd foutcorrigerend vermogen t naar boven begrensd is door dH,min/2, d an vinden we dat het gegarandeerd fractioneel foutcorrigerend vermogen t/n van een lineaire code naar boven begrensd is (op een asymptotische wijze voor grote n) door de helft van de redund antie (1 — Rc)/2 die de code toevoegt. Lange codes met debiet R, = 1/2 kunnen dus niet meer d an 25% foutieve symbolen in een codewoord corrigeren. Een andere interessante interpretatie van de Singletongrens is dat t voor lange codes naar boven begrensd is door (n — k)/2, wat betekent dat er ten minste twee pariteitsbits nodig zijn voor elk foutief bit dat men wil corrigeren.

128

5.3.3 Plotkingrens De Plotkingrens is een bovengrens voor de minimale Hammingafstand van een code voor gegeven n en k. Het principe v an de Plotkingrens is dat het minimale Hamminggewicht van een code niet groter kan zijn dan het gemiddelde Hamminggewicht van alle codewoorden. Het kan aangetoond worden dat, indien alle codewoorden in een binaire (n, k) code worden neergeschreven als rijen van een matrix, elke kolom van de matrix 2k -1 keer de bit 1 bevat. Aangezien er n kolommen zijn in de matrix, is de som van de gewichten van alle codewoorden gegeven door n2k -1 . Er zijn 2k — 1 codewoorden verschillend van nul. Aangezien het minimale Hamminggewicht v an een code niet groter kan zijn dan het gemiddelde Hamminggewicht, vinden we de bovengrens dH,min

n2 k-1

<

(5.55)

2k — 1

Delen we beide leden door n en nemen we de limiet voor k -3 oo, dan vinden we dat de minimale Hammingafstand als fractie van de bloklengte n naar boven begrensd is door 1/2, ongeacht het debiet R van de code. Het dient opgemerkt te worden dat deze bovengrens in het algemeen zeer onnauwkeurig is, in het bijzonder voor hoge debieten.

5.3.4 Eliasgrens Tenslotte is er nog een andere, veel nauwkeuriger bovengrens voor de minimale Hammingafstand van een code. De Eliasgrens in as ymptotische gedaante kan worden geschreven als dH,min < 2a(1 — a), (5.56)

n

waarbij de parameter a gerelateerd is met het debiet van de code via de uitdrukking R^

= 1 + a log2 a + (1 — a) log2 (1 — a) = 1 — 7L(c ),

0

< a < 1/2 (5.57)

waarbij 7-1(a) de binaire entropiefunctie is van een binaire bron met probabiliteiten a en 1 — a.

5.3.5 Varsharmov-Gilbertgrens Er bestaan ook ondergrenzen voor de minimale Hammingafstand. In het bijzonder geldt voor binaire codes dat de genormaliseerde minimale Hammingafstand op een as ymptotische wijze voldoet aan de volgende ongelijkheid: dH,min

>a

n

' 129

(5.58)

0.5 0.45 0.4 0.35 0.3 dH,,

.,

0.25

n 0.2 0.15 0.1 0.05 0 0

0.2

0.4

0.8

0.6

Codedebiet R

1

^

Figuur 5.9: Asymptotische boven- en ondergrenzen voor de genormaliseerde dH,min versus het codedebiet voor binaire codes. waarbij a gerelateerd is tot het codedebiet R, via (5.57). Deze ondergrens is een speciaal geval van een ondergrens opgesteld door Gilbert en Varsharmov. In figuur 5.9 worden de asymptotische versies van de Hamming, de Singleton, de Plotkin en de Eliasbovengrenzen getoond voor de minimale Hammingafstand dy ,min genormaliseerd op de codelengte n, alsook de Varsharmov-Gilbertondergrens, als functie van het codedebiet Rc . Deze figuur geeft duidelijk aan welke minimale Hammingafstand men kan bekomen voor lange codes bij verschillende codedebieten. De genormaliseerde minimale Hammingafstand moet in het grijze gebied liggen.

130

Hoofdstuk 6 Niet - binaire polynomiale codes 6.1 Definitie Bij een (n, k) polynomiale code wordt de te versturen sequentie van symbolen opgedeeld in blokken van k symbolen. Zulk een blok van k symbolen noemt men het informatiewoord b = (b0 , ... , bk_1 ). In de encoder wordt het informatiewoord b omgezet in een codewoord c van lengte n (n > k): c = (co, ... , ci_ 1 ), met an dere woorden, er worden n — k extra symbolen toegevoegd die redundante informatie bevatten. Een andere manier om het codewoord c voor te stellen is de polynomiale notatie. In deze polynomiale notatie gebruikt men de n elementen co , ... , c,i _ 1 als de coëfficiënten van een veelterm in x: c(x) = co + c1x + ... + cn_ix 1 (6.1) Het informatiewoord b kan men op dezelfde manier voorstellen. Het debiet v an de code (code rate) wordt gegeven door R = k/n. In een polynomiale code gebeurt de omzetting van het informatiewoord in een codewoord met behulp van een generatorveelterm g(x) = .90+

g1x + ... + gn_k xn- k:

(6.2) Hieruit volgt dat een codewoord steeds een veelvoud is van de generatorveelterm g(x). Om deze veeltermen te kunnen vermenigvuldigen en andere bewerkingen op deze veeltermen te kunnen uitvoeren is het noodzakelijk dat we de coëfficiënten van de veeltermen kunnen optellen, aftrekken, vermenigvuldigen en delen. Dit is mogelijk indien de coëfficiënten elementen zijn van een eindig veld. c(x) = g(x)b(x)

6.2 Eindige velden (Galois velden) Een eindig veld GF(q), ook Galois veld genoemd, is een eindige set van q elementen waarvoor we een aantal rekenregels hebben gedefinieerd. Een eindig veld heeft de volgende eigenschappen: 131

Tabel 6.1: Vermenigvuldigen in GF(5) • 0 1 2 3 4 0 0 0 0 0 0 1 0 1 2 3 4 2 0 2 4 1 3 3 0 3 1 4 2 4 0 4 3 2 1 1. Twee bewerkingen zijn gedefinieerd om de elementen te combineren: optelling en vermenigvuldiging. 2. Het resultaat van een optelling of vermenigvuldiging van twee elementen uit het eindige veld is steeds een element van dit eindige veld. 3. Het eindige veld bevat steeds een eenheidselement voor de vermenigvuldiging 1 en een eenheidselement voor de optelling 0. Dus, a + 0 = a en a • 1 = a, voor alle mogelijke elementen a. 4. Elk element a heeft een invers element voor de optelling (—a) en een multiplicatief invers element (a -1 ), zodat a + (—a) = 0 en a • (a -1 ) = 1. Merk op dat 0 -1 niet gedefinieerd is. Het bestaan van deze elementen laat toe de begrippen aftrekking en deling te definiëren. 5. De associatieve [a + (b + c) = (a + b) + c en a • (b c) _ (a • b) • c], commutatieve [a + b = b + a en a • b = b •a] en distributieve [a • (b + c) = a • b + a • c] regels zijn voldaan Een eindig veld bestaat niet uit om het even welk aantal elementen. In het algemeen bestaat een eindig veld enkel indien het aantal elementen een priemgetal is (in dit geval spreekt men van een priemveld) of een macht van een priemgetal (in dit geval spreekt men van een uitbreidingsveld). Voor elke waarde q bestaat er slechts één uniek veld. Dit betekent dat er slechts één enkele manier bestaat om de rekenregels voor optelling en vermenigvuldiging te definiëren zodat a an de andere eigenschappen van een eindig veld voldaan is. Indien q een priemgetal is, dan zijn de elementen van het eindige veld 0, 1, ... , q— 1, en de optelling en vermenigvuldiging worden gedefinieerd als modulo-q. In tabellen 6.1 en 6.2 worden de vermenigvuldiging en optelling voor het priemveld GF(5) getoond. Aftrekking en deling kunnen bekomen worden door in de tabel de inverse elementen te zoeken en deze dan gewoon op te tellen of te vermenigvuldigen.

132

Tabel 6.2: Optellen in GF(5) + 0 1 2 3 4 0 0 1 2 3 4 1 1 2 3 4 0 2 2 3 4 0 1 3 3 4 0 1 2 4 4 0 1 2 3 Voorbeeld: 3-4 = 3+(-4) = 3+1 =4 en 3/4 = 3.4 -1 = 3.4 =2

Indien q een macht is van een priemgetal (bijvoorbeeld q = pm), dan bestaan de elementen van het eindige veld uit alle mogelijke veeltermen van de graad m - 1, waarbij de coëfficiënten van deze veelterm elementen zijn van het priemveld GF(p). De rekenregels voor optellen en vermenigvuldiging in dit geval bestaan uit het optellen en vermenigvuldigen van de veeltermen op de gewone manier en daarna het reduceren van het resultaat modulo een speciale veelterm p(D) van graad m. Deze veelterm moet irreduceerbaar zijn. Een veelterm wordt irreduceerbaar genoemd indien deze veelterm niet kan opgesplitst worden in een product v an veeltermen waarbij deze veeltermen coëfficiënten hebben die element zijn van het priemveld GF(p). Voorbeeld: de veelterm p(D) = D2 + 1 is niet irreduceerbaar over GF(2) want: D2 +1=(D+1)•(D+1)

De coëfficiënten v an D +1 (nl. tweemaal 1) zijn immers elementen van het eindige veld GF(2) = {0,1}. De veelterm p(D) = 1+ D + D3 daarentegen is wel irreduceerbaar over GF(2) en kan gebruikt worden als basis om GF(8) te construeren. Stel dat 0 1 = 1 + D + D2 en 02 = 1 + D2 twee elementen zijn in GF(8). De som van de twee elementen is 01+ 02 = (1+ D+D2 )+(1+D 2) = (1 + 1) • 1 + D + (1 + 1) • D 2 =D 133

en het product van de twee elementen is Ql

132 = (1+ D + D2 ) • (1 + D2 ) = 1+D+D2 +D2 +D3 +D4 3 +D4 =1+D

Om deze uitdrukking te reduceren modulo-p(D), maken we gebruik van de gelijkheid p(D) = 0. Hieruit volgt: D3 = 1+ D D4 = D + D2 en 131 /32 = 1 + D +( 1 = D +D 2

+ D) + (D + D2 )

Merk op dat de modulo-p(D) reductie van een veelterm overeenkomt met het delen van de veelterm door p(D) en het behouden van de rest. Dit kan zeer eenvoudig worden geverifieerd aan de hand v an het voorgaande voorbeeld. Een concept dat hier dicht bij aanleunt is de congruentie van twee veeltermen. Men zegt dat a(D) congruent is met b(D) modulo-p(D) indien geldt a(D) b(D) mod p(D) (6.3) Dit betekent dat a(D) en b(D) dezelfde rest hebben na deling met p(D). Uit het voorgaande volgt dat a(D) — b(D) deelbaar is door p(D). De definitie van een logaritme in een eindig veld is zeer gelijkaardig a an dat voor de reële get al len. Om de logaritme te kunnen definiëren moeten we eerst de termen 'orde van een element' en 'primitief element' invoeren. De orde van een element a uit GF(q) wordt gedefinieerd als het kleinste positieve get al € waarvoor at = 1. Daarnaast is een eigenschap van eindige velden het bestaan van minstens één primitief element. Een primitief element is een element van het eindige veld waarvoor geldt dat elk ander element van het veld (het nulelement uitgezonderd) uitgedrukt kan worden als een macht v an dit primitief element. Dit betekent dat de orde van een primitief getal in GF(q) gelijk moet zijn aan q — 1. Voorbeeld:

Uit tabel 6.1 volgt dat het element 2 een primitief element is van

GF(5): 21 22 23 24

= = = = 134

2 4 3 1

(6.4)

en 25 =2 1 =2 De orde van het element '1' daarentegen is 1, aangezien 1 1 -1 2 -1 3 -1 4 -1 5 -1

en kan dus niet gebruikt worden om de logaritme te definiëren. Hieruit volgt dat een andere m an ier van vermenigvuldigen bestaat uit het bepalen van de logaritme (met basis het primitief element) van het gewenste element, gedefinieerd door (6.4), het optellen van deze logaritmen modulo-4, en dan via (6.4) het inverse logaritme te vinden. Merk op dat het nodig is de volgende definitie in te voeren: 2° = 1

net zoals in het geval van de reële getallen. Dezelfde concepten kan men nu ook toepassen op een uitbreidingsveld, bijvoorbeeld GF(8). Stel dat a = D, dan vinden we dat: a2 a3 a4 a5

= = = = as = a7 =

D2 D3 =1+ D D+D2 D 2 + D3 = 1+ D+D2 D+D2 +D3 =1+D2 D+D3 =1

(6.5)

We kunnen dus twee elementen in G F(8) vermenigvuldigen met behulp van (6.5) (definitie van de logaritmen), daarna tellen we de logaritmen op modul o- 7, en tenslotte gebruiken we (6.5) om de inverse logaritme te bepalen. In dit voorbeeld bleek D een primitief element te zijn van GF(8), zodat het eenvoudig was een tabel met logaritmen op te stellen. Het vinden van een primitief element is niet altijd zo eenvoudig. Echter, in de praktijk zal D steeds een primitief element zijn van het uitbreidingsveld indien de irreduceerbare veelterm die gebruikt wordt voor het definiëren van de veldoperaties een primitieve veelterm is. Wat het verband is tussen primitieve elementen en primitieve veeltermen zal later in deze cursus duidelijk worden. In de literatuur bestaan tabellen die aangeven of een irreduceerbare veelterm ook primitief is. Om problemen te vermijden kan men dus steeds een primitieve veelterm gebruiken bij het definiëren van de veldoperaties. Het bestaan van logaritmen in eindige velden betekent dat er een notatie is voor de elementen van het eindige veld die bruikbaar is voor vermenigvuldiging en een andere notatie die bruikbaar is voor optelling. Eenmaal de omzetting van de ene notatie naar de andere notatie gekend is, is het niet meer noodzakelijk de veeltermen expliciet uit 135

Tabel 6.3: Omzetting tussen de gewone notatie en de logaritmische notatie voor de elementen van GF(8) 0 a° = 1 al a2

a3 a4

t—+

a5

^

0 1 0 0 1 0 1

a6

H

1

H 4-4

E—a ^

0 0 1 0

0 0 0 1

1

0

1 1 0

1 1 1

te schrijven. Een kortere notatie kan gebruikt worden waarbij het element uitgedrukt wordt als een vector van lengte m bij optelling en een macht van een primitief element bij vermenigvuldiging. In het geval van GF(8) is de notatie in tabel 6.3 equivalent met de notatie in (6.5). Met behulp van tabel 6.3 kan men op een zeer eenvoudige manier bewerkingen uitvoeren in GF(8). Voorbeeld:

Een functie f (D) kan op de volgende manier geëvalueerd worden.

Stel dat f (a) = (a 2 + a5 )a + (1 + a3 )a

Uit tabel 6.3 volgt a2 + a5 = a3 en 1 + a3 = a. Dus f(a)

= a3 •a+a•a = a4 + a2 = a = (0 1 0)

In sommige gevallen is het niet a angewezen veel omzettingen te doen tussen de twee notaties. Een oplossing hiervoor is het Zech-algoritme, z(n), gedefinieerd door az(n) =1 + an

(6.6)

Met deze techniek kan men alle bewerkingen uitvoeren enkel met behulp van de logaritmische notatie, zonder de tabel voor de inverse logaritme te moeten gebruiken. De elementen am en an kunnen opgeteld worden als volgt: am + an = am (1

= a m-fz(n

an-m -

m)

)

(6.7)

De tabel met de Zech-logaritmen voor GF(8) wordt getoond in tabel 6.4. Met behulp van deze tabel vinden we = a2+ z (3) = a3 136

Tabel 6.4: Zech-logaritmen voor GF(8) n z(n) —00 0 0 —oo 1 3 2 6 3 1 4 5 5 4 6 2 De elementen v an het eindige veld spelen dezelfde rol voor veeltermen met eindige veld coëfficiënten als complexe getallen voor veeltermen met reële coëfficiënten. Net zoals veeltermen met reële coëfficiënten kunnen gefactoriseerd worden indien men het bestaan van complexe getallen toelaat, kan elke veelterm met coëfficiënten uit een eindig veld gefactoriseerd worden met behulp v an elementen uit een uitbreidingsveld. Het verb an d tussen de factoren en de wortels van een veelterm met coëfficiënten uit een eindig veld is immers hetzelfde als het verband tussen de factoren en de wortels van een veelterm met reële coëfficiënten. Bijvoorbeeld, een veelterm f (D) kan opgesplitst worden in de volgende factoren: (6.8) f (D) (D — Q^ waarbij de j waarden van )3 de wortels zijn van de veelterm f (D). Er bestaan een aantal eigenschappen van veeltermen en eindige velden die nuttig zijn in het beschrijven van codes. Deze eigenschappen worden hieronder vermeld zonder bewijs. Eigenschap 1: Irreduceerbare veeltermen. Een veelterm met coëfficiënten uit een bepaald eindig veld wordt irreduceerbaar genoemd indien deze veelterm niet kan gefactoriseerd worden met enkel elementen van het beschouwde eindige veld. Echter, dezelfde veelterm kan wel gefactoriseerd worden met elementen uit een uitbreidingsveld. Hieruit volgt dat een irreduceerbare veelterm steeds wortels zal hebben in het uitbreidingsveld. Stel f (D) is een irreduceerbare veelterm met coëfficiënten uit GF(p), en a is een wortel van de veelterm, d an zijn a", ap2 , aP3 , enz. ook wortels v an de veelterm. Alle wortels v an f (D) kunnen gevonden worden op deze wijze. De veelterm f (D) wordt de minimale functie van a genoemd. Indien a een primitief element is, dan is f (D) een primitieve veelterm.

_

fli)(D —N2)...(D —

)

Voorbeeld: De veelterm f (D) = 1 + D + D3 is irreduceerbaar over GF(2). Het element a in tabel 6.3 is een wortel aangezien

f(a) = 1 +a + a3

_ (1 0 0) + (0 1 0) + (1 1 0) = (0 0 0) = 0 137

Volgens de bovenstaande eigenschap moeten dus ook a 2 en a4 wortels zijn. f (a2 ) = 1 + a 2 + a6 = (1 0 0) + (0 0

1) + (1

0 1)

1)+0.

1 1)

= (0 0 0) = 0 en f (a4 )

=

= = =

1 + a4

+ ai2

1+a4 +a5 (1 0 0)+0 1 (0 0 0)=0

Verder, als a, a 2 en a4 wortels zijn van f (D), dan is het mogelijk f (D) te schrijven als f (D) = (D — a)(D — a 2 )(D — a4 )

= D 3 — D2 (a + a2 + a 4 ) + D(a3 + a5 + a6 ) — (a7) D3 +D+1 Eigenschap 2: f (Dp) = fP(D). Indien f (D) een veelterm is met coëfficiënten uit GF(p), dan geldt steeds (6.9) f (D9 ) = fP(D) Dit volgt uit het feit dat alle kruistermen gegenereerd in fP(D) ofwel p keer ofwel een veelvoud van p keer voorkomen, zodat hun som modulo-p gelijk is aan nul.

Voorbeeld: (1+ D +D2)2 = 1+D2 +D 4 +2(D+D2 +D3 ) = 1 +D2 +D4

Merk op dat eigenschap 2 gebruikt kan worden om aan te tonen dat eigenschap 1 geldt. Eigenschap 3: Factoren van Dm — 1. De orde m van een eindig veld is de kleinste waarde waarvoor geldt Om = 1. Bij definitie is Q een wortel van Dm — 1. Indien /3 een wortel is van een irreduceerbare veelterm f (D), dan moet f (D) een factor zijn van Dm —1. Eigenschap 4: GF(p) en wortels van Dp m-1 — 1. De wortels van D' m-1 — 1 zijn alle niet-nul elementen van GF(pm). Voorbeeld: (eigenschappen 3 en 4) De veelterm f (D) = D7 — 1 kan gefactoriseerd worden als D7 -1 = (D3 +D 2 +1)(D3 + D+1)(D+ 1) Met behulp van tabel 6.3 kunnen we vinden dat D 3 + D + 1 de wortels a, a2 4 heeft, D 3 + D2 + 1 de wortels a 3 , a5 en a6 heeft, en de wortel van D + 1 ena is 1. Deze zeven wortels zijn de zeven niet-nul elementen van GF(8). 138

6.3

Constructie van polynomiale codes

Een methode om een polynomiale code te definiëren is via de wortels. Een veelterm met coëfficiënten in GF(q) is dan een codewoord enkel en alleen indien het de wortels 01, /32, ... , /3,. heeft, waarbij 0i een element is van GF(qm). Dit betekent dat c(x) een codewoord is enkel en alleen indien c(f1 ) = 0, c(fz ) = 0, enz. Nemen we als voorbeeld de veeltermen van graad 6 of lager met coëfficiënten in GF(2) en veronderstellen we dat een van de wortels v an de code a is, d an zijn deze veeltermen codewoorden enkel en alleen indien a (een element uit GF(8), zie tabel 6.3) een wortel is van deze veelterm. Aangezien 1 + x + x3 de minimale functie is v an a, is dit equivalent met te zeggen dat elk codewoord deelbaar is door 1+x + x3 . Merk op dat het opleggen v an de voorwaarde c(0) = 0 hetzelfde is als eisen dat c0 00

c101

+ C2/3 2 +...+ cn-lh' n -1

=0

(6.10)

waarbij Cj i = 0, ... , n — 1 de coëfficiënten zijn v an het codewoord c(x). Voor de code uit het voorgaande voorbeeld (zie tabel 6.3) vinden we: ,

1

co

0 0

0

+ cl

1 0

0

+ cz

0 1

+ c3

1 1 0

1

0

+ c4 1

+ C5

1

1

1

1

+ C6

0 1

= 0

Merk op dat slechts één wortel van de set /3, /3 9 , 13Q2 , enz. moet beschouwd worden in de definitie van de code, aangezien f (13Q) = f 4 (/3). Indien de code gedefinieerd wordt op deze m an ie n moeten de wortels 01 , /32 , ... , /i, ook wortels zijn van de generatorveelterm g(x) (definitie zie (6.2)) van de code. Stel dat m,(x) mi(x) de minimale functie is van 0z , d an kanmedgrtovlandecokfirals g(x) = KGV [m l (x), mz(x), • • • , m,.(x)]

(6.11)

waarbij KGV erop wijst dat het kleinste gemene veelvoud moet genomen worden v an de veeltermen binnen de haakjes. Veel praktische codes worden op deze m an ier gedefinieerd. Een veelgebruikte klasse van codes zijn de BCH codes (BCH staat voor de initialen van de namen v an de uitvinders van de codes: Bose, Chaudhuri en Hocquenheim). BCH codes zijn codes die meerdere symboolfouten kunnen corrigeren, en op een zeer eenvoudige manier gedefinieerd worden aan de hand v an de wortels vageneratorveeltermterm. Definitie: Een primitieve t-foutencorrigerende BCH code in GF(q) met een bloklengte n = qm — 1 (=lengte codewoord) heeft am0, am 0 +1 , amo+2t-1 als wortels van de generatorveelterm g(x) (voor om het even welke waarde v an m° ), waarbij a een primitief element is van GF(gm). Dit betekent dat de generatorveelterm van een BCH code geschreven kan worden als volgt: (6.12) g(x) = KGV [mmo (x), mmo+i (x), ... , mmo+zt-1(x)] 139

De codes met mo = 1 worden 'narrow-sense' BCH codes genoemd. Niet-primitieve BCH codes worden op een zeer gelijkaardige manier gedefinieerd, behalve dat in plaats van een primitief element a een niet-primitief element Q uit GF(gm) wordt genomen, en de bloklengte n van de code wordt dan de orde van de wortel O. Voorbeeld: We zoeken de generatorveelterm voor een 'narrow-sense', 2foutencorrigerende BCH code met bloklengte n = 7. Dit betekent dat a, a 2 , a3 en a4 wortels moeten zijn van de generatorveelterm g(x), waarbij a een primitief element is van GF(8). Stel dat het eindige veld GF(8) gedefinieerd is zoals in tabel 6.3. Hiermee kunnen we de minimale functies bepalen van de verschillende wortels:

_

mi (x) = m2(x) = m4(x) (x — a)(x — a 2 )(x — a4 ) = x3 + x +1 en m3(x) = (x — a 3 )(x — a 6 )(x — a5 )

= x3 +x2 +1 Dit betekent dat de generatorveelterm gegeven is door g(x) _ (x 3 + x +1)(x3 + x2 +1) = x6 +x 5 +x4 +x3 +x2 + x +1

Deze g(x) genereert de triviale (7,1) repetitieve code (het informatiewoord bestaat uit één symbool en in het codewoord wordt dit symbool zevenmaal herhaald). In werkelijkheid kan deze code alle foutpatronen met drie fouten corrigeren. Dit is niet ongewoon: in veel gevallen kan een BCH code meer fouten corrigeren dan gespecificeerd werd voor de code. Een aantal voordelen van BCH codes zijn de eenvoudige constructie en de grote vrijheid in bloklengte en codedebiet. De BCH codes zijn niet alleen belangrijk wegens hun flexibiliteit in de keuze van de codeparameters, maar ook omdat deze codes voor kleine bloklengtes (n < 500) tot de codes behoren die het beste presteren in vergelijking met andere codes met dezelfde bloklengte en codedebiet. Een ander voordeel is dat het decoderen van deze codes op een zeer eenvoudige manier kan geïmplementeerd kan worden, gebruik makend van algebraïsche technieken (zie later in dit hoofdstuk). Een belangrijke subklasse van de BCH codes zijn de codes waarvoor m o = m = 1. Deze codes worden Reed-Solomon codes genoemd. Reed-Solomon codes hebben een toep assing 140

in o.a. CD-spelers en 'Deep Space' communicatie. Deze codes zijn niet-binaire codes en hebben een bloklengte n = q — 1. De generatorveelterm voor deze codes is gegeven door g(x) = (x—a)(x —a 2)...(x

—

(6.13)

a2t)

Merk op dat de graad van de generatorveelterm 2t is, zodat slechts 2t pariteitssymbolen nodig zijn om t fouten te kunnen corrigeren. Typisch wordt q = 2' genomen. Dit betekent dat de codesymbolen die corresponderen met m bits kan corrigeren, zodat de code 'burst'fouten (m.a.w. opeenvolgende bitfouten) kan verbeteren. Voorbeeld: We zoeken de generatorveelterm voor de 2-foutencorrigerende Reed-Solomoncode met bloklengte 7. Opnieuw veronderstellen we dat GF(8) gedefinieerd is zoals in tabel 6.3. Gebruik makend van (6.13) vinden we g(x) = (x — a)(x — a 2 )(x — a 3 )(x — a 4 ) = x4

+ a3 x3 +x2 + ax+ a3

We vinden dus een (7,3) code die alle foutpatronen met twee fouten kan corrigeren. Merk op dat de coëfficiënten van de generatorveelterm typisch elementen zijn van GF(8).

6.4

Generatie van polynomiale codes

In het begin van dit hoofdstuk hebben we een (n, k) polynomiale code gedefinieerd als de volledige set van veeltermen van graad n of lager die de generatorveelterm g(x) als factor hebben. De generatorveelterm heeft de graad n — k. Voorbeeld:

Indien g(x) = 1+ x + x3

(6.14)

dan zal de set van codewoorden gevormd door de vergelijking c(x)

= (1 + x + x3)(ao + al x + a2x2 )

(6.15)

een (6, 3) code vormen. Merk op dat er exact acht verschillende veeltermen ao + a lx + a2x2 zijn die overeenstemmen met de acht verschillende manieren om ao, al en a2 te kiezen uit GF(2). Een mogelijkheid om deze code te gebruiken is door a o, al en a2 gelijk te stellen a an deinformatsybl,devrmnigu tevor.Hsulaidn c(x)

= ao + (a0 + a l )x + (al + a 2 )x2 + (ao + a2)x 3 + ai x4 + a 2x5

(6.16)

Een schema dat deze vermenigvuldiging uitvoert wordt getoond in figuur 6.1. Hoewel deze manier van encoderen correct is, heeft deze methode het nadeel dat de code in het algemeen 141

geheugenelement

modulo-2

optelling

ao,al,a2

ao , ao+al , al+a2 , ao +a2 , al , a2

Figuur 6.1: Schuifregister voor het vermenigvuldigen van een willekeurige veelterm a o + + a2x2 met g(x) = 1+ x + x3

alx

niet systematisch is (nl. waarbij de informatiesymbolen ongewijzigd worden doorgestuurd). In dit voorbeeld is de code systematisch in de posities 1, 5 en 6. Echter, dit zal niet steeds het geval zijn. Een eigenschap van (n, k) polynomiale codes is dat zij steeds systematisch kunnen gemaakt worden in de k eerste posities. Stel dat we definiëren bo = ao b1 = ao + al b2 = a1 + a2

(6.17)

Indien we (6.17) oplossen naar de a's en substitueren in (6.16), dan bekomen we de codeveelterm c(x

)

= bo + b1 x + b2x2 + (b1 + b2 )x3 + (b 0 + bi )x4 + (bo + b 1 + b2 )x5

(6.18)

We hadden evenwel andere posities kunnen kiezen waarin de code systematisch moest zijn, bijvoorbeeld: c(x)

= (bo + b2 ) + (bo + b1 + b2 )x + (b 1 + b2 )x2 + box3 + b1 x4 + b2x5

(6.19)

De laatste keuze heeft meestal de voorkeur, wegens redenen van implementatie die later duidelijk zullen worden. Het is duidelijk dat men een encoder kan bouwen voor deze systematische codes door eerst de a's uit te drukken als een lineaire combinatie van de b's en dan het schuifregister van figuur 6.1 te gebruiken voor de vermenigvuldiging. Een tweede methode, die de twee stappen in de voorgaande methode combineert is de volgende. Stel we vermenigvuldigen de veelterm b o + b1x + b2x2 met x3 resulterend in box3 + b 1 x4 + b2x5 . Delen we dit resultaat door 1 + x + x3 , dan bekomen we een quotient (bo +b2)+b1 x+b2x2 en een restveelterm (bo + b2) + (bo+b1+b2)x+ (b1+b2)x2 . Merk op dat 142

tijdstip 0•-- ■N r 1

inhoud schuifregister 0 0 0 b2 b2 0 b1 b1+b2 b2 bo+b2 b 1 +b2 bo+b1+b2

Figuur 6.2: Schuifregister voor het gelijktijdig vermenigvuldigen met x 3 en delen door 1 + x +x3 indien we deze restveelterm aftrekken van de veelterm b ox3 + bl x4 + 62x5 , we het codewoord bekomen in de systematische vorm v an (6.19). Deze procedure is een toepassing van het Euclidische delingsalgoritme: deeltal = (quotient) • (deler) + rest In het algemene geval van een (n, k) code wordt het informatiewoord eerst vermenigvuldigd met xn-k . De graad v an de restveelterm is steeds lager dan de graad van de deler (graad deler = n — k). Aangezien het informatiewoord vermenigvuldigd werd met xn -k , zal het deeltal enkel termen bevatten met exponent groter of gelijk aan n — k. Hieruit volgt dat het optellen van de restveelterm bij het deeltal geen invloed heeft op de coëfficiënten van beide veeltermen. Door als deler de generatorveelterm te kiezen, zal het resultaat steeds een codewoord zijn. Een implementatie van deze methode voor de (6,3) code wordt getoond in figuur 6.2. In dit schuifregister worden b2 , 61 en bo één na één ingevoerd. De inhoud van de geheugenelementen na elke verschuiving wordt weergegeven in de figuur. Na drie verschuivingen bevat het schuifregister de rest na deling. Het quotient verschijnt als de opeenvolgende termen in de feedback loop (eerste kolom in de tabel). Het schema in figuur 6.2 is zeer eenvoudig, aangezien alle bewerkingen modul o- 2 zijn (in GF(2)). In het algemene geval, wanneer een code gedefinieerd is over GF(q), moeten de vermenigvuldigingen expliciet uitgevoerd worden. Stel dat de generatorveelterm van de volgende vorm is: g(x) = gn_ k xn -k + ... + g1x + go, waarbij alle gi elementen zijn van GF(q). In dit geval moet het schema in figuur 6.2 aangepast worden als volgt. Ten eerste, alle optellingen zijn modulo-q zodat de resultaten elementen zijn van GF(q). Ten tweede, de uitgang van de opteller die de feedback levert moet vermenigvuldigd worden met 9,; 1 k . Tenslotte, voor alle gi (i < n — k) die verschillend zijn van nul, moet de feedback term vermenigvuldigd worden met —gi in GF(q) (modulo-q). Het resultaat moet dan opgeteld 143

b i, bo

Figuur 6.3: Schuifregister voor het vermenigvuldigen met xn—k en delen door g(x) worden met het getal in het ide geheugenelement (i = 0, ... , n — k — 1). Het algemene encoderingsschema wordt getoond in figuur 6.3. Merk op dat polynomiale codes lineair zijn: indien b i (x) en b2 (x) twee informatiewoorden zijn die overeenstemmen met de codewoorden c1 (x) en c2 (x), dan is het codewoord dat overeenstemt met de som van de twee informatiewoorden b1 (x)+b2 (x) gelijk aan de som van de twee codewoorden cl (x) + c2 (x). Dit kan zeer eenvoudig geverifieerd worden aan de hand van (6.18) of (6.19). Verder geldt dat BCH codes (en dus ook Reed-Solomon codes) cyclisch zijn: indien (c o , cl , ... , cn_ 1 ) een codewoord is, dan is elke cyclische verschuiving van dit codewoord ook een codewoord, m.a.w. (c 1i ... , cn_ 1i co ) is eveneens een codewoord. De voorwaarde voor het cyclisch zijn van een code is immers (zie Datacommunicatie) dat de generatorveelterm g(x) een deler moet zijn v an xn — 1, waarbij n de bloklengte is van de code. De bloklengte van een BCH code is gelijk aan n = qm — 1 en de wortels van de code zijn elementen uit GF(gm). Wegens eigenschappen 3 en 4 uit de vorige sectie volgt dat de wortels van xn — 1 alle niet-nul elementen zijn van GF(gm) en dat de minimale veeltermen van deze wortels dus factoren zijn van xn —1. De generatorveelterm bestaat uit het product van minimale veeltermen, en is dus ook een factor van xn — 1. Dit verklaart het cyclische karakter van BCH codes.

6.5 Generatormatrix en checkmatrix Tot nu toe hebben we polynomiale codes beschreven a an de hand van een generatorveelterm. Een andere m anier om een polynomiale code te beschrijven is het gebruik van de matrixnotatie. Dit is mogelijk aangezien een polynomiale code lineair is: de som van twee codewoorden steeds een codewoord. Passen we dit principe meermaals toe, dan bekomen we dat elke lineaire combinatie van codewoorden steeds een codewoord vormt. Men kan dus verwachten dat, aangezien de informatiesymbolen onafhankelijk van elkaar verondersteld kunnen worden, men verschillende codewoorden kan vinden die elk overeenstemmen met een informatiewoord waarvan één enkel informatiesymbool gelijk is aan '1' en alle andere informatiesymbolen gelijk zijn aan nul. Het is dus mogelijk alle qk codewoorden te vormen door alle qk mogelijke lineaire combinaties te nemen v an deze k basisvectoren. M.a.w. een polynomiale code heeft alle eigenschappen van een lineaire vectorruimte. 144

De generatormatrix G v an een (n, k) polynomiale code wordt opgebouwd uit de basisvectoren van de vectorruimte die gevormd wordt door de code, nl. elke rij van de generatormatrix bevat één van de k basisvectoren. Op deze wijze kan men een k x n matrix construeren. Deze generatormatrix definieert een lineaire transformatie waarmee men de codewoorden kan berekenen: c = bG (6.20) waarbij het codewoord c = (co , el , . . . , c,,,- i ) en het informatiewoord b = (bo , b1 , ... , bk _ 1 ). Voorbeeld: Beschouwen we de (7,4) polynomiale code met generatorveelterm g(x) = 1 + x + x3 in CF(8). De systematische vorm van het codewoord is

gegeven door: c(x)

= b3x6 + b 2x5 + b1 x 4 + box3 + (b1 + b2 + b3)x2 b2)x +(bo+b2+b3) +(bo1

(6.21)

Hieruit kunnen we de vier basisvectoren halen: 1 + x + x3 = co (x) = C1 (x) = x4 = x + x2 + c2 ( x) = 1 + x + x2 + x5 = c3 (x) = = 1 + x2 + x6

(1 1 (0 1 (1 1 (1 0

0 1 1

1 0 0

1 0

0 0 0) 1 0 0) 0 1 0) 0 0 1)

We vinden dan de generatormatrix

G—

1101000 011010 0 1 1 1 0 0 1 0 1 0 1 0 0 0 1

(6.22)

Merk op dat indien we de eerste en tweede rij onveranderd laten, de eerste rij bij de derde optellen, en de eerste en tweede rij bij de vierde rij, we een nieuwe generatormatrix G' vinden G'

—

1 1 0 1 0 0 0 011010 0 0 0 1 1 0 1 0 0 0 0 1 1 0 1

rij. Hieruit blijkt opnieuw het waarbij elke rij een cyclische verschuiving is van de cyclische karakter v an de code. [P|Ik] schrijven We kunnen steeds de generatormatrix in zijn systematische vorm G = [PlIk] door rijoperaties op de generatormatrix uit te voeren. In dit geval zullen de laatste k symbolen van het codewoord de informatiesymbolen zijn. De eerste n—k codesymbolen zijn een 145

lineaire combinatie van de informatiesymbolen. Deze symbolen worden de pariteitssymbolen genoemd, en het verband tussen de pariteitssymbolen en de informatiesymbolen wordt voorgesteld door de k x (n — k) pariteitsmatrix P. De checkmatrix H van een code wordt gedefinieerd als de matrix waarvoor geldt GHT = 0

(6.23)

Merk op dat er geen unieke oplossing bestaat voor deze vergelijking. Het algemene verband tussen de checkmatrix en de generatormatrix zowel voor binaire als niet-binaire codes kan geschreven worden als volgt. Voor een generatormatrix in de systematische vorm [P| Ik G = [PIIk]

(6.24)

is de bijbehorende checkmatrix gegeven door (6.25)

H = [In-k i — P T]

De checkmatrix heeft dimensies (n—k) xn. Hieruit volgt dat, indien we de generatormatrix in zijn systematische vorm (6.24) schrijven, we de checkmatrix direct eruit kunnen afleiden, en vice versa. Wat is nu het nut van de checkmatrix? Vermenigvuldigen we een codewoord met de checkmatrix: cHT = bGHT = b [ P Ik ] [ In-Pk

J = b(P — P) = 0

(6.26)

Omgekeerd, indien cHT = 0, dan is c een codewoord. Op deze manier kunnen we nagaan of een woord een codewoord is. Dit heeft zijn nut bij het decoderen. Voorbeeld: We zoeken de checkmatrix voor de (7,4) code met generatorveelterm g(x) = 1+x+x3 in GF(8) uit het vorige voorbeeld. Uitgaande van (6.22) bekomen we 1 0 0 1 0 1, 1

H= 0 1 0 1 1 1 0 001 0111

6.6 Het syndroom Een eerste stap in veel decodeerschema's voor polynomiale codes is het berekenen van het syndroom van de ontvangen sequentie. Stel dat een ontvangen woord r een foutpatro an r geschreven worden als ]evat.Indglk r

=c +e

146

(6.27)

Vermenigvuldigen we het ontvangen woord met de checkmatrix H, dan bekomen we het syndroom s s = rHT = cHT + eHT eHT =

(6.28)

Dit betekent dat de checkmatrix ons toelaat een grootheid te definiëren die enkel afhangt van het foutpatroon. Bij het decoderen tracht men dan het foutpatroon op een of andere manier te reconstrueren, zodat men het correcte codewoord k an terugvinden. Merk op dat twee ontvangen woorden die hetzelfde syndroom hebben gelijk zijn op een codewoord na. Men kan het syndroom ook in polynomiale notatie bekomen. Er bestaan drie gedaantes voor het syndroom in polynomiale notatie. In een eerste gedaante definiëren we de syndroomveelterm S(x) als de (n — k — 1)graadsveelterm die bekomen wordt door de ontvangen sequentie te delen door de generatorveelterm en de restveelterm te behouden: S(x) = r(x) mod g(x)

(6.29)

Aangezien alle codewoorden deelbaar zijn door g(x) zal S(x) duidelijk onafhankelijk zijn van het verstuurde codewoord maar enkel afhangen van het foutpatroon. Men kan gemakkelijk aantonen dat deze definitie van de syndroomveelterm identiek is aan de definitie van het syndroom in matrixnotatie. In sectie 6.4 hebben we aangetoond dat het codewoord met behulp v an een schuifregister kan gegenereerd worden. Een zeer gelijkaardig schema als in figuur 6.3 kan gebruikt worden om de syndroomveelterm te bekomen. Het schema in figuur 6.4 deelt de veelterm r(x) door de generatorveelterm g(x). Na n tijdstippen bevat het schuifregister de restveelterm. Voorbeeld: Beschouwen we de (7,4) polynomiale code met generatorveelterm g(x) =1 + x + x3 in GF(8) met de algemene vorm v an het codewoord (6.21). We ontvangen het woord r(x) = 1 + x2 + x4 + x5 en voeren dit woord in in

de structuur getoond in figuur 6.5. Na zeven verschuivingen vinden we de rest na deling, nl. de restveelterm x 2 . Merk op dat indien we de veelterm x6 = (1 0 0 0 0 0 0) invoeren in het schuifregister, de inhoud v an het schuifregister op de verschillende tijdstippen overeenstemt met de kolommen van de checkmatrix H, nl. 1 0 0 1 0 1 1 H= 0 1 0 1 1 1 0 0 0 1 0 1 1 1

Een tweede gedaante voor de syndroomveelterm kan gedefinieerd worden indien de generatorveelterm uit twee of meerdere irreduceerbare factoren bestaat. Stel dat g(x) = gi(x)g2(x)...gi(x) 147

(6.30)

r(x) Figuur 6.4: Schuifregister voor het berekenen van de syndroomveelterm S(x) r(x) r

schuifregister

r

schuifregister 00 -.0 ^

--*.--.

--. 00^0.--. .-.

, -+^^0

■

--.00 00 00

O^O

,

-. 0 0--. 0

000--, .-..-.--.

■

0■

O0■ --.•--..-4■ --•O

0 •-

0._.._.0 r.

r(x)= 1+x2+x4+x5

r(x) =x6

Figuur 6.5: Deling van r(x) door g(x) = 1 + x + x3 In dat geval definiëren we j syndroomveeltermen als Si (x) = r(x) mod gi (x) S2 (x) - r(x) mod g2 (x)

(6.31)

S3 (x) =

r(x) mod gl (x)

Deze tweede vorm van het syndroom bevat dezelfde informatie als de eerste vorm. Het bewijs hiervan is een direct gevolg van de Chinese reststelling voor veeltermen. Uit deze Chinese reststelling volgt dat er een uniek verband is tussen de restveelterm S(x) en de restveeltermen S 1 (x), S2 (x) enz. Voorbeeld: Stel dat de generatorveelterm gegeven is door g(x)_ (x 3 + x2 + 1)(x3 + x + 1) =x6 +x5 +x4 +x3 +x2 +x+1

Aangezien beide veeltermen wortels hebben van orde 7, zal g(x) een code genereren met bloklengte 7. De checkmatrix die correspondeert met het syndroom S(x) halen we uit het schuifregister en is gegeven door 148

/ 1 0 0 0 0 0 1\ 0100001 010001 H= 0 0001001 0000101 \0000011 Indien het syndroom nu gespecificeerd is als Si (x) - r(x)mod(x 3 + x + 1)

en S2(x) - r(x)mod(x 3 + x2 + 1)

dan kunnen we uit de corresponderende schuifregisters de bijbehorende checkmatrix H' halen / 1 0 0 1 0 1 1\ 0101110 010111 H' _ 0 1001110 0100111 \ 0 0 1 1 1 0 1) De checkveeltermen Si(x) en S2(x) kunnen onafhankelijk van elkaar berekend worden door twee verschillende schuifregisters te gebruiken. Echter, indien we S(x) reeds berekend hebben en we hebben Si (x) en S2(x) nodig, dan kunnen we dit doen via een lineaire transformatie die de rijen van H omzet in H'. Noemen we de ide rij van H, h4, en de ide rij van H', hi, dan vinden we

hi = hi +114 + h6 h2 = h2+h4+h5 +h6 h3 = h3 + h5 + h6 h4 = hi+h4+h5+h6 h'6 = h2 + h5 + h6 hs = h3+h4+h5

(6.32)

De omgekeerde transformatie is gegeven door

hi = h; +h3 +hs h2 = hi +h2+h3+h4+ h6 h3 = h; +h2+h4 + h5 +h6 h4 = h2 + h5 h5 = hi + h4 h6 = h2+h3+h5+h4 149

(6.33)

Si (x)

S2(x)

Figuur 6.6: Berekenen van Si (x) en S2(x) uitga an de van S(x)

S(x)

Figuur 6.7: Berekenen van S(x) uitgaande van Si(x) en S2(x) Figuur 6.6 toont het schuifregister dat eerst S(x) berekent en daarna (6.32) gebruikt om S1(x) en S2(x) te berekenen. In figuur 6.7 is de volgorde omgekeerd: eerst worden S i (x) en S2(x) berekend met behulp van twee schuifregisters en daarna wordt S(x) berekend uitga an de van (6.33). Deze laatste transformatie wordt echter zelden gebruikt. Een derde gedaante van het syndroom ontstaat door het definiëren van de vectoren S 1 , S2, enz. als = r(Q1) S2 = T(82)

S1

(6.34)

waarbij A. een wortel is v an g1 (x), /32 een wortel van g2 (x), enz. De checkmatrix die met 150

deze gedaante overeenstemt is gegeven door

H --=

P1 P1 Qi ... a2 02 Q2 .. •

(6.35)

or

QT rr

Wanneer de checkmatrix in deze vorm geschreven wordt, dan moeten we enkel één wortel uit de set 0, ,q, 13Q2 , enz. beschouwen, a an gezien f (QQ) = fQ(Q). De checkmatrix H" voor het vorige voorbeeld is gegeven door /1 0 0 1 0 0

0 1 0 1 1 0

0 0 1 1 0 1

1 0 1 11 1 0 0 0 1

1 1 1 1 1

1 1 0 1 0

0 1 0 1 1/

Men kan gemakkelijk aantonen dat H" kan berekend worden uitgaande van H' via h" 1 = h'1 h"2 = h'2 h" 3 = h'3

114 = h4+h16 +hg h"5 = h' hs = hfi

(6.36)

Deze berekening kan uitgevoerd worden met het schema uit figuur 6.8. Een andere mogelijkheid is het rechtstreeks berekenen van S 1 en S2 uit r(x), zoals in figuur 6.9 te zien is. De verbindingen in het schuifregister dat S2 berekent, kunnen gevonden worden door de laatste drie rijen van H" te inspecteren. Hieruit kan men vinden dat een enkele verschuiving ervoor zorgt dat de inhoud van het eerste geheugenelement naar het eerste en het tweede geheugenelement gaat, de inhoud van het tweede geheugenelement gaat naar het tweede en het derde geheugenelement, en de inhoud van het derde geheugenelement gaat naar alle drie de geheugenelementen.

6.7 Algebraïsche decodeertechnieken Foutcorrectie bij polynomiale codes kan men bekomen door een stelsel van algebraische vergelijkingen op te lossen. Een methode om fouten te corrigeren is het gebruik van de checkmatrix. In het vervolg van dit hoofdstuk beschouwen we enkel het geval van BCH 151

s,

SS2

Figuur 6.8: Berekenen van S 1 en

S2

uitgaande van S1 (x) en S2(x)

s2

S,

Figuur 6.9: Rechtstreekse berekening van S 1 en codes, met wortels amo, amo+1 , gens (6.35), dan bekomen we

H =

,

S2

amo+ 2t -1 Beschouw de checkmatrix gedefinieerd vol-

1 1

amo a*no+1

1

a mo +2t-1

a2m0

a 2(mo+1)

a(n-1)mo a (n-1)(mo +1)

(6.37) a 2(mo+2t -1)

a (n-1)(mo +2t - 1 )

Noemen we de foutvector e = (e o , el , ... , en_ 1 ) met polynomiale notatie e(x) = eo + e 1 x + ... + en _ i xn -1

(6.38)

dan kan het ontvangen woord r geschreven worden als r = c + e. Vermenigvuldigen we het ontvangen woord met de checkmatrix, S = rHT = eHT

(6.39)

dan bekomen we het syndroom S,, j = 1, 2, ..., 2t n-1

S

=

[^ L^

et a(mo +.i -1)i

i= o

152

(6.40)

Het stelsel van 2t vergelijkingen bevat enkel de componenten van de foutvector e, maar niet de componenten van het codewoord. Hiermee kunnen we dus het foutpatroon bepalen. Stel dat er v (0 < v < t) fouten optreden in de onbekende posities i l ... , i,,. De foutvector kan dan geschreven worden als ,

e(x) =

,

(6.41)

x11 + ei2 x^2 + ... + eix i '

waarbij ei[ de waarde van de ede fout voorstelt. We kennen noch de posities i, ... , i,, noch de waarden e i1 , ... , ei„ van de fouten. We kennen zelfs v niet. Al deze waarden dienen bepaald te worden teneinde de fouten te kunnen corrigeren. De eerste stap in het decoderen is het evalueren van de syndromen gegeven door (6.40). Berekenen we de syndromen, dan bekomen we, rekening houdend met (6.41), het stelsel van 2t vergelijkingen in v onbekende foutposities i, ... i„ en de v onbekende foutwaarden e, 7 ..., ei„ . eiv a(+no+j-1)i„ Si = ei,a (mo+9-1)i1 + ei2 a (mo +j —1)i2 (6.42) Dit stelsel van vergelijkingen heeft ten minste één oplossing, rekening houdend met de manier waarop het syndroom is gedefinieerd. Men kan aantonen dat de oplossing uniek is indien 0 < v < t. ,

,

,

Voorbeeld: We beschouwen de 2-foutencorrigerende binaire BCH code met bloklengte 15. Deze code heeft wortels a, a 2 , a3 en a4 , waarbij a een primitief element is in GF(16). De generatorveelterm corresponderend met deze code is g(x)

= gl (x)92(x)

met

= (x — a)(x — a 2)(x — a4)(x — a 8 ) g2(x) = (x — a 3 )(x — a 6)(x — a 9 )(x — (1 12 ) gl(x)

De

checkmatr ix corresponderend met deze code is gegeven door H

=

al a2 3 a a23

a15 3

a15

De {ai }, i = 1, ... ,15 zijn de verschillende niet-nulelementen uit GF(24 = 16). Indien fouten optreden op posities i en j in het ontvangen woord, dan levert de evaluatie van de syndromen twee vergelijkingen op in twee onbekenden, nl. ai + = Sl a 3 + a^ = S2

Lossen we de eerste vergelijking op naar aa en substitueren we dit in de tweede vergelijking, dan bekomen we a^ +

+S;+ S2 /S1= 0 153

,

Hadden we de vergelijkingen opgelost naar a i dan hadden we dezelfde (kwadratische) vergelijking gevonden voor a i . Hieruit volgt dat zowel ai als aa oplossingen (wortels) zijn van dezelfde veelterm, nl. ,

z2 + Slz

+ s? -i- S2 /s1 = 0

We kunnen dus samenvatten dat het decodeeralgoritme uit twee stappen bestaat: 1. De evaluatie van de syndromen met behulp van (6.40). 2. Het oplossen van een stelsel van 2t niet-lineaire vergelijkingen gegeven door (6.42) om de foutposities en de foutwaarden te vinden. Het oplossen van dit niet-lineaire stelsel is zeer moeilijk, behalve voor kleine waarden van t. Een methode om dit stelsel van niet-lineaire vergelijkingen via een aantal tussenstappen op te lossen wordt later in dit hoofdstuk beschreven. In deze sectie zijn we uitgegaan van de specifieke eigenschappen van BCH codes (nl. de codeveelterm heeft wortels met opeenvolgende machten). Het is duidelijk dat de uitbreiding van deze methode naar andere polynomiale codes triviaal is.

6.8 Transformaties in eindige velden Vooraleer we een algoritme kunnen opstellen om het niet-lineaire stelsel op te lossen, is het noodzakelijk de Fouriertransformatie in een eindig veld te definiëren. De discrete Fouriertransformatie in een eindig veld C van een vector c is gedefinieerd als volgt: Definitie: Noemen we c de n-dimensionale vector met coëfficiënten uit een eindig veld GF(q) (waarbij qm — 1 deelbaar is door voor bepaalde m), en stel dat a een element is van GF(qm) en orde n heeft. In dat geval is de Fouriertransformatie van c in het eindige veld de vector C = (Co , C1i ... , Cn_ 1 ), waarbij C gedefinieerd is in GF(qm) en gegeven is door

n

n-1

C, _ E aijci ,

(6.43)

j = 0, ... , n — 1

i=o Deze definitie is zeer gelijkaardig aan de definitie van de discrete Fouriertransformatie van wortel van 1 in het een reële vector waarbij de Fourierkern a vervangen is door de We noemen de discrete index i de tijdsindex en de index j de complexe veld, e -.'hn. frequentie-index. Dit betekent dat de vectoren c en C de respectievelijke functies in het tijdsdomein en het frequentiedomein (of spectrum) zijn. De twee vectoren vormen een Fourierpaar, (6.44) c<=.>C

n`e

154

Het verband tussen de vector c en zijn spectrum C in GF(q) met karakteristiek p is gegeven door n

Cj

-

1

= E a`

^

(6.45)

ci

i=0

1

Ci =

n-1

E a - i7 Cj

n (mod p)

(6.46)

j =o

Veel van de eigenschappen van de reële Fouriertransformaties (zoals convolutie) zijn ook geldig bij dit Fourierpaar in het eindige veld. Een aantal van deze eigenschappen zijn zeer bruikbaar in het begrijpen van de eigenschappen van foutcorrigerende codes die meerdere fouten kunnen corrigeren.

Voorbeeld: Stel dat de componenten c i bestaan uit het product van twee andere vectoren f en g: = .fi9i

i = 0,...,n — 1

^

(6.47)

Dan kan de Fouriertransformatie geschreven worden als n-1

^` aill

Cj

_

fi9i

4=0

1 E a fa —E n-1

n-1

ij

n k=0

=

i 0

n-1

n-1

=

Gka-ik

n E Gk

(

k=0

>aii_k fi i =0

)

(6.48)

n-1

= 1

nE k=0

GkFj -k

waarbij alle indices modulo-n zijn. Hieruit volgt dat een vermenigvuldiging in het tijdsdomein overeenstemt met een convolutie in het frequentiedomein, en omgekeerd. De vectoren c en C kunnen ook voorgesteld worden als veeltermen: c(x) = co + cl x + + cn- l xn -1 en C(z) = Co + Cl z + ... + Cn - l zn -1 . Met deze notatie vindt men dat de jde spectrale component gegeven is door Cj

=

(6.49) 155

Dit betekent dat Cj = 0 enkel en alleen indien al een wortel is van c(x). Op dezelfde wijze vinden we dat de ide tijdscomponent gegeven is door C{

_

n-1 a -ij Cj j=0

n

(6.50)

C(a -` )

Dit kan samengevat worden in de volgende eigenschap. Eigenschap: Het verband tussen de wortels van de veelterm in het ene domein en de componenten in het andere domein is als volgt 1. De veelterm c(x) heeft aj als wortel enkel en alleen indien Cj = 0. 2. De veelterm C(z) heeft a -i als wortel enkel en alleen indien c ;, = 0. We merken dat het definiëren van wortels in het ene domein overeenstemt met het nul stellen van de bijbehorende componenten in het andere domein. Deze eigenschap is zeer nuttig bij het decoderen van polynomiale codes. Voorbeeld: Beschouw de vector c = (0, 0, 1, 3) in GF(5). De eindige-veld Fouriertransformatie is ook gedefinieerd in GF(5) en heeft componenten 3

Cj

2`'c, E i=0

=

1.223 +3.233 ,

j = 0,1,2,3

We hebben in deze transformatie het element 2 met orde 4 gekozen uit GF(5). De regels voor optellen en vermenigvuldigen zijn gegeven in tabellen 6.1 en 6.2. We vinden dan C = (4,3,3,0) als de Fouriertransformatie. Merk op dat GF(5) karakteristiek 5 heeft en dat 4-1 = 4. De inverse transformatie wordt dan 3 c^

=

4

E 2 - t'Cj j =0

= 4(4+3.2 -i +3.2 -22 ),

i = 0,1,2,3

Na uitvoeren van deze operaties vinden we de oorspronkelijke vector c terug. Merk op dat de vector c twee nulcomponenten heeft, c ° en c1 . Uit de eigenschap volgt dan dat de veelterm C(z) = 4+3z+3z2 als wortels 2° en 2 -1 heeft. Indien we deze waarden substitueren, vinden we inderdaad dat deze waarden wortels zijn van C(z). 156

Merk op dat een codewoord c(x) = b(x)g(x), waarbij b(x) de informatieveelterm met graad k —1 voorstelt en g(x) de generatorveelterm met graad n— k, kan geschreven worden als n-1

z_ib; (6.51) J=0 m.a.w. de generatie van het codewoord (vermenigvuldiging van twee veeltermen) stemt overeen met een convolutie in het tijdsdomein, dus een vermenigvuldiging in het frequentiedomein: = GjBj . Aangezien het informatiewoord b(x), dus B(z) een willekeurige grootheid voorstelt, kan een code gedefinieerd worden met behulp van de wortels a&1, aaa, , ain-k van de generatorveelterm, zoals reeds vermeld in sectie 6.3, of door het specificeren van het spectrum G(z) (of C(z)), nl. het spectrum moet steeds nul zijn in de componenten j1, j2,... , in-k. Hieruit volgt dat we een andere definitie kunnen geven voor primitieve BCH codes. Definitie: Een primitieve t-foutencorrigerende BCH code in GF(q) met bloklengte n = qn` — 1 is de set van alle codewoorden in GF(q) waarvan het spectrum nul is in 2t opeenvolgende componenten mo , mo + 1, ... , mo + 2t — 1. De eigenschap dat de generatorveelterm g(x) van een BCH code 2t opeenvolgende machten van a als wortel heeft (of anders dat het spectrum 2t opeenvolgende componenten heeft die nul zijn), zorgt ervoor dat BCH codes tot t fouten kunnen corrigeren. Dit volgt uit de volgende stelling. Stelling: Indien een niet-nul vector c een spectrum C heeft met d — 1 opeenvolgende componenten die nul zijn (C, = 0 : j = m0 , mo + 1, ... , mo + d — 2), dan heeft c minstens d componenten verschillend van nul. Bewijs: Stel dat c v < d componenten heeft die verschillend zijn van nul in posities i1, i2 , ... , i,,, en dat de Fouriertransformatie van c gelijk is aan nul in de posities m o , mo + 1, ... , mo + d — 2. Definieer de foutlocatorveelterm als =

A(z) = 11(1

:

—

g

zaik)

k=1

= Ave + AL - I ZL -1 +...+Ao

(6.52)

dat zijn inverse transforDan heeft de vector A een spectrum dat gedefinieerd is zoda matie A nulcomponenten (A, (Ai 0) heeft voor alle i waarvoor c,: 0. Er geldt dus A c,ci = 0 in het tijdsdomein, en de overeenstemmende convolutie in het frequentiedomein is ook nul: n-1

E AkC;-k = 0

(6.53)

k=0

Echter, A(z) heeft een graad die ten hoogste gelijk is aan d — 1 en Ao = 1, zodat d-1

Cj = - E nkc.l- k k=1

157

(6.54)

Dit kan beschouwd worden als de vergelijking van de uitgang C 5 van een schuifregister met feedbackveelterm A(z). Met behulp van (6.54) kan men de volledige sequentie C, berekenen uitgaande van elk blok van d — 1 opeenvolgende Cd's. Echter, we hebben verondersteld dat er een blok van d-1 Ci 's bestaat die alle nul zijn (voor de indices m o , mo +1, ... , mo +d-2). Gebruiken we dit blok als beginvoorwaarde, dan volgt hieruit dat alle C5 = 0, dus de vector c is de nulvector. Een gevolg hiervan is dat elke vector verschillend van nul tenminste d componenten moet hebben verschillend van nul. QED Het gevolg van deze stelling is dat indien g(x) een blok van 2t opeenvolgende machten van a als wortel heeft, de afst an d tussen de codewoorden minimaal gelijk is aan d = 2t+1. Deze 2t opeenvolgende nulcomponenten v an C zijn v an belang bij het decoderen. Uit de 2t opeenvolgende componenten in de Fouriertransformatie van het ontv an gen woord, waar het codewoord nul is, halen we het syndroom. Het foutpatroon kan hieruit berekend worden indien er niet meer dan t fouten aanwezig waren.

6.9

Decoderen van BCH codes

Zoals eerder vermeld kan het ontv an gen woord geschreven worden als de modulo-q som van het verstuurde codewoord en een foutvector: r = c + e. De ontvanger kent enkel r uit observaties en moet gebaseerd hierop de foutvector e met het kleinste Hamminggewicht vinden die de geobserveerde r kan produceren. Het Hamminggewicht d1 (x) van een vector x is gegeven door dH (x) _ Exi

(6.55)

i=1 M.a.w. de ontvanger moet voor deze vector e een keuze maken uit qn mogelijkheden. Er bestaan verschillende methoden om deze foutvector te bepalen, zowel in het frequentiedomein als in het tijdsdomein. In deze cursus bespreken we enkel een methode in het frequentiedomein. In de methode in het frequentiedomein berekent men eerst de Fouriertransformatie R van de ontvangen vector r. Deze tr an sformatie kunnen we schrijven als de som van de transformaties v an het codewoord en de foutvector: R=C+E

(6.56)

Uit de definitie v an de BCH code vinden we dat de transformatie van elk codewoord nul is in 2t opeenvolgende posities. Uit (6.56) kunnen we dus een set van 2t waarden E3 bepalen - de syndromen. We hernoemen deze 2t waarden: E^

= Rj = S';-m o

7 = me, mo +1,...,mo +2t-1

(6.57)

Merk op dat deze definitie v an het syndroom equivalent is met de derde gedaante van het syndroom (6.35) in sectie 6.6. Een manier waarop men het decoderen kan bekijken 158

is de volgende. We kennen reeds 2t waarden Ei ; hiermee moeten we de andere n — 2t componenten bepalen zodat we een schatting Ê van de foutvector in het frequentiedomein vinden, waarvan het Hamminggewicht van de inverse transformatie ê minimaal is. Stel nu dat er v < t fouten zijn. Definieer de foutlocatorveelterm A(z) zoals in (6.52) waarbij de indices i i , i2, ... , i„ corresponderen met de tijdsindices van de v fouten (ei k 0; k = 1, 2, ... , v). Dan geldt in het tijdsdomein dat Ai = 0 wanneer ei # 0, zodat aiei = 0 voor alle waarden van i en n-1

E

AkEj—k =

0

(6.58)

k=0

Merk op dat Ak = 0 voor k > v en Ao = 1. Het stelsel van vergelijkingen dat men uit deze convolutie (6.58) haalt is de "sleutel" tot het oplossen van het decodeerprobleem en wordt de sleutelvergelijking genoemd. Aangezien we 2t opeenvolgende componenten van E kennen, kunnen we (6.58) gebruiken om v vergelijkingen neer te schrijven in de v onbekenden Ak. Deze vergelijkingen zijn lineair in de onbekenden en kunnen opgelost worden met behulp van gewone matrixinversietechnieken. Ze kunnen echter ook opgelost worden met behulp van iteratieve technieken. Een iteratieve techniek zal besproken worden in sectie 6.10. Eenmaal de sleutelvergelijking gevonden is, kan men de onbekende componenten van Ê vinden via (6.58) op een recursieve wijze. Tenslotte, eenmaal Ê gevonden is, kan ê bepan.ld worden als de inverse Fouriertransformatie van Ê, en de uitgang van de decoder levert c=r ê (6.59) —

Een blokschema van deze decoder wordt getoond in figuur 6.10. De Fourietansfmdyroenbkt,apzernvoudigmaïplentrd worden. Merk op dat aangezien de generatorveelterm van de code de wortels a mo amo+1 , amo+2e-1 heeft, de 2t syndroomsymbolen gedefinieerd zijn als E9+mo n-1 e ai(9+mo) a

=

i =0

= e(a„1+n`o)

Schrijven we het

j de

j = 0,1, ... , 2t — 1

(6.60)

syndroomsymbool als 9^

= rn_ ia(n-1)(3+mo) + rn-2a(n-2)(i+mo) + ... + ro

(6.61)

dan is het duidelijk dat het schema uit figuur 6.11 deze berekening uitvoert. Het recursieve algoritme om Ê te berekenen kan uitgevoerd worden zoals getoond in figuur 6.12. Deze implementatie bestaat uit een gewoon feedbackschuifregister waarbij de verbindingen bepaald worden door de veelterm A(z). Tenslotte kan de inverse transformatie van E uitgevoerd worden op een zeer gelijkaardige m an ier als in figuur 6.11, maar dan met n i.p.v. 2t van deze blokken. 159

4,

bereken tran sformatie (mo<j<m 0+2t-1) A

oplossen sleutelvergelijking

A --^

^

recursieve E —► uitbreiding

bereken

inverse transformatie

(Si :j=0,1,...,2t)

A

buffer

Figuur 6.10: Decoder in het frequentiedomein voor BCH codes

j+mo

a

Figuur 6.11: Berekening van Si

6.10

Oplossen van de sleutelvergelijking

De eenvoudigste manier om de sleutelvergelijking op te lossen is gebruik te maken van het algoritme van Euclides. Het algoritme v an Euclides is een recursief algoritme om de grootste gemene deler van twee getallen of twee veeltermen te vinden. Het algoritme werkt als volgt. Stel dat a en b twee getallen of veeltermen voorstellen, waarbij a > b indien a en b getallen zijn of deg(a) > deg(b) indien a en b veeltermen zijn. Deel a door b. Indien de rest r gelijk is aan nul, dan is d = b de grootste gemene deler. Indien de rest niet gelijk is a an nul, vervang dan a door b, b door r en herhaal de bewerking. De toepasbaarheid van het algoritme kan aangetoond worden met een eenvoudig voorbeeld.

Figuur 6.12: Feedbackschuifregister voor het recursief berekenen van de fout

160

Stel dat we twee gehele getallen hebben a = 186 en b = 66. Dan vinden we 186 66 54 12

= = = =

(66)2 + 54 (54)1 + 12 (12)4 + 6 (6)2 + 0

Aangezien d 186 en 66 deelt, moet het ook 54 delen. Aangezien het 66 en 54 deelt, moet het ook 12 delen. Tenslotte, aangezien het 54 en 12 deelt, moet het ook 6 delen. Hieruit volgt dat 6 de grootste gemene deler is. In het proces om de grootste gemene deler te vinden, berekent het algoritme twee getallen, of veeltermen, f en g zodat (6.62)

fa + gb = d

Het nuttige a an dit algoritme is niet het eindresultaat, maar de tussenresultaten. Bij elke tussenstap worden de getallen of veeltermen fi en gi gegenereerd zodat fia

+ gib = ri

(6.63)

Het recursieve verband voor f en ri wordt duidelijk indien we het voorbeeld herbeschouwen. De eerste vergelijking is reeds in de juiste vorm, zodat de eerste iteratie van het algoritme het volgende genereert: 1(186) — 2(66) = 54

De tweede vergelijking bevat de a anwijzingen voor de tweede iteratie. Schrijven we 66=66 en trekken we de bovensta an de vergelijking af, d an vinden we —(186) + 3(66) = 12 Op dezelfde manier vinden we de derde en de vierde iteratiestap: 5(186) — 14(66) = 6 en

—11(186) + 31(66) = 0 Merk op dat in elke stap de volgende vergelijking gevonden word door de twee vorige stappen te combineren volgens Xi

(6.64)

= xi -2 — gixi - 1

waarbij qi het quotient is v an de twee vorige resten, en xi = fi gi of ri. Formeel kunnen we nu het volgende recursieve verband opschrijven. Aangezien we voornamelijk geïnteresseerd zijn in veeltermen, zullen we enkel dit geval beschrijven. We ,

161

Tabel 6.5: Een voorbeeld van het algoritme van Euclides met a(z) = z3 + 1 en b(z) = z2 +1 i fi(z) 9i(z) qi(z) ri(z) -1 1 0 z3 + 1 —

0 1 2

0 1 z +1

1

z2 +1

z

z+1

z2 +z+1

0

—

z z +1

definiëren qi (z) als de veelterm die we bekomen door de veelterm r i_2 (z) te delen door de veelterm rti _ 1 (z) [ ri2 ( z) ]

qi(z) =

( r1z) o

(6.65)

waarbij [ ]ó betekent dat we enkel de niet-negatieve exponenten van z beschouwen. Dan vinden we ri(z) = ri-2(z) — gi(z)ri -1(z) fi (z) = fi-2(z) — gi(z)fi-1(z) 9i(z) = 9i-2(z) — gi(z)9i -1(z)

(6.66)

De beginvoorwaarden voor het algoritme zijn f_ 1 (z)

= go(z) = 1

fo(z) = g_1(z) = 0 r_ 1 (z) = a(z) ro (z) = b(z)

(6.67)

deg[ri (z)] < deg[rt_ 1 (z)]

(6.68)

Het algoritme werkt zo dat voor alle waarden van i. Dit betekent dat het algoritme altijd convergeert naar een rest gelijk aan nul in een eindig aantal stappen. Het voorbeeld met a(z) = z3 + 1 en b(z) = z2 + 1 is getoond in tabel 6.5. De laatste rest verschillend van nul r i (z) = z + 1 is de grootste gemene deler. Voorbeeld:

We zijn echter niet geïnteresseerd in het vinden van de grootste gemene deler, maar in het oplossen van de sleutelvergelijking. Hiervoor definiëren we eerst de syndroomveelterm

162

van oneindige graad (waarvan de eerste 2t coëfficiënten gegeven zijn door (6.60)) 00

S(z)

=

Sjzi i=o 00 x7

e a ik(Tnbi-7)

ik j=0 k=1 e•tk atkmo -

k=1

(6.69)

za4

Het product A(z)S(z) kan geschreven worden als

A ( z )S( z ) =

E eika tkrito 11(1 — zat`) U

U

k=1

tok

St(z)

(6.70)

De veelterm 11(z) wordt de foutevaluatieveelterm genoemd. Merk op dat voor een foutlocatorveelterm met graad v, de foutevaluatieveelterm steeds een graad heeft kleiner dan v. In werkelijkheid is de veelterm S(z) slechts gekend op een factor zet-1 na, zodat geldt

A(z)S(z) = 11(z) mod z2t

(6.71)

De toepasbaarheid v an het algoritme van Euclides wordt duidelijk indien opgemerkt wordt dat (6.63) k an geschreven worden als

gi (z)b(z) = ri (z) mod a(z)

(6.72)

Kiezen we a(z) = zet , dan wordt deze vergelijking

gi (z)b(z) - r i (z) mod z2t

(6.73)

wat de sleutelvergelijking is indien gi (z) = Ai (z) en ri (z) = 11 (z). Dit betekent dus dat men met het algoritme van Euclides een oplossing kan vinden voor de sleutelvergelijking. Om in te zien dat het algoritme van Euclides aanleiding geeft tot de gewenste oplossing van de sleutelvergelijking, gebruiken we de volgende eigenschap van het algoritme v an Euclides: deg[gi (z)] + deg[ri_1(z)] = deg[a(z)] Stellen we a(z)

(6.74)

= z2t , d an vinden we deg[gi (z)] + deg[ri_ 1 (z)] = 2t

(6.75)

deg[gi (z)] + deg[ri (z)] < 2t

(6.76)

en 163

Tabel 6.6: Oplossing van de sleutelvergelijking voor t-foutencorrigerende BCH codes 1. Pas het algoritme v an Euclides toe voor a(z) = z et en b(z) = 8(z) 2. Gebruik de beginvoorwaarden uit (6.67) 3. Stop het algoritme wanneer deg[r n (z)] < t 4. Stel A(z) = gn (z) en 11(z) = rn (z) Tabel 6.7: De gewone en logaritmische voorstelling van de niet-nulelementen uit het veld GF(24), met p(x) = x4 + x +1 i a' i at 8 0101 0 0001 1 0010 9 1010 2 0100 10 0111 3 1000 11 1110 4 0011 12 1111 5 0110 13 1101 6 1100 14 1001 7 1011 Merk op dat indien v < t fouten optreden, er voor de gewenste oplossing geldt dat deg[St(z)] < deg[A(z)] < t. Er bestaat slechts een enkele veelterm A(z) (op een constante factor na) met graad kleiner of gelijk aan t die voldoet aan de sleutelvergelijking. Verder, indien deg[ri_ i (z)] > t en dus deg[gi (z)] < t en deg[ri (z)] < t, dan deg[gi +i (z)] > t. Dit betekent dat de tussenresultaten in de id' stap aanleiding geven tot de enig mogelijke oplossing van de sleutelvergelijking. Hieruit volgt dat voor het oplossen van de sleutelvergelijking we het algoritme van Euclides moeten toepassen totdat deg[r i (z)] < t. Deze methode is samengevat in tabel 6.6. De toep as sing van het algoritme zal nu worden geïllustreerd aan de hand van twee voorbeelden. De berekeningen gebeuren in het veld GF(2 4 ), gebruik makend van de tabel 6.7. Voorbeeld 1: Beschouw de 3-foutencorrigerende binaire BCH code met bloklengte 15. Neem m° = 1 zodat de generatorveelterm de wortels a, a 2 , ... , a6 an GF(24 ). Stel dat het ontv an genheft,warbijnpmeltisv woord gegeven is door

r(x) = x3 + x10

De coëfficiënten van het syndroom kunnen berekend worden met (6.60): S = (a3+1)3

+ (a,i+1)io.

j =0 1

5

Hieruit halen we de syndroomveelterm 8(z) = ai4zs + a 10z4 + a3z3 + a7z2 + a 9z + a 12

164

(6.77)

Tabel 6.8: Oplossing van de sleutelvergelijking voor S(z) gegeven door (6.77) i Ai (z) S21 (z) qi (z) 1 0 z6 0 1 S(z) 1 az+ a 12 a3z4 + a2z3 + a2z2 + z + a 9 az + a' 2 a ll z + a6 al l 2 a 12 z2 + a ll z + a14 -

—

—

Met de beginvoorwaarden a(z) = z 6 en b(z) = S(z) vinden we met het algoritme van Euclides de oplossing van de sleutelvergelijking en we bekomen de foutlocatorveelterm getoond in tabel 6.8. Merk op dat de oplossing gevonden wordt bij de i waarvoor deg[Sl i (z)] < t = 3. De foutlocatorveelterm wordt dan A (z) = a 12z2 + a11z + a14 Deze veelterm specificeert een feedbackschuifregister dat de transformatie v an v opeenvolgende defoutvcrkanb i(6.58)denblokva waarden gekend zijn. Voor dit voorbeeld vinden we dus

1

Ê = a12Ê

_i + a 13 4-2

De gekende waarden zijn E; = (j = 1, 2, ... , 6). Door recursieve berekening vinden we de volledige transformatie van de foutvector: E = (0,, a12, a9 , a7 , as , a io , a14 , a 7 ,as , a11, a5 , a ll , a ls , a ls , a 14) Nemen we de inverse transformatie, d an vinden we de foutvector ê = (0,0,0,1,0,0,0,0,0,0,1,0,0,0,0)

Indien we deze foutvector gebruiken om de ontv angen vector te corrigeren, dan vinden we de nulvector als codewoord. Voorbeeld 2: Als tweede voorbeeld beschouwen we de 3-foutencorrigerende Reed-Solomoncode met bloklengte 15 gedefinieerd in GF(24 ). De wortels van de generatorveelterm zijn a, a 2 , ... , a6 . Veronderstel we ontvangen het woord r(x) = a7 x3 + a 11 x10

De coëfficiënten van het syndroom zijn gegeven door Si = a7(a3+1)3 +, a ll(ai+1)10 De overeenstemmende syndroomveelterm wordt dan S(z) = a 14 z5 + a 14 z4 + a 12z3 + a6z2 + a 12z + a7 165

(6.78)

Tabel 6.9: Oplossing van de sleutelvergelijking voor S(z) gegeven door (6.78) i

A2 (z) 0

-1

0; (z)

4i (z)

z6 S(z)

1 az + a 2 a 9 z 2 + as + a ll 0 1

asz4

a5z3

a5z2 + a3 z + a8 az + a a8 + all

az z + a3

Passen we het algoritme van Euclides toe, dan vinden we de foutlocatorveelterm zoals in tabel 6.9. A(z) = a9z 2 + a8z + all De foutvector in het frequentiedomein kunnen we recursief bepalen via (6.58): E^

= a 1z Ej- 1 + a13 E^ -z

Hiermee vinden we s a 7 , a l2 a,6 a l2 a l4 al4 1 0 a l3 a lo a,8 a,4 all , l , , , , , , , , , , , , , 1) a

_

(

Na inverse transformatie vinden we de foutvector ê

= (0,O,O,a e ,0,0,0,0,0,0, a ll , 0,0,0,0)

Na correctie van het ontvangen woord bekomen we het codewoord c(x) = r(x) — ê (x) = 0 Vatten we deze resultaten samen, dan zien we dat de toepassing van het algoritme van Euclides op S(z) aanleiding geeft tot een sequentie van oplossingen voor de sleutelvergelijking waarbij de graad v an Ai (z) toeneemt en de graad van 52 i (z) afneemt. Echter, er werd aangetoond voor BCH codes dat voor elk patroon v an t of minder fouten, deg[A(z)] > deg[S2(z)]. Hieruit volgt dat de enige oplossing, die correctie van de gewenste foutpatronen garandeert, bekomen wordt bij de eerste i waarvoor deg[St i (z)] < t.

6.11

Performantie

Het st an daard BCH decodeeralgoritme kan geen foutpatronen met meer dan t fouten corrigeren. Deze eigenschap zorgt ervoor dat de performantie van een BCH code zeer eenvoudig te berekenen is. Voor een t-foutencorrigerende BCH code met bloklengte n, is de symboolfoutprobabiliteit gegeven door de kans dat er meer dan t fouten optreden in het codewoord: (6.79) Ps (n)Pi— ( 1 p) n-` — —

E

i =t +l

166

waarbij p de kans is dat een symboolfout optreedt in het beschouwde kanaal. De symboolfoutprobabiliteit PS houdt rekening met zowel de niet-gedetecteerde symboolfouten als het onvermogen van het algoritme om foutpatronen met meer dan t fouten te corrigeren. Een bovengrens voor de bitfoutprobabiliteit Pb in een binaire BCH code kunnen we vinden via de pessimistische veronderstelling dat een foutpatroon met i kanaalfouten (i > t) ervoor zorgt dat het gedecodeerde woord van het verstuurde codewoord verschilt in i + t posities, zodat een fractie (i + t)/n informatiesymbolen foutief gedecodeerd worden.

E Pb
nt

( 1 — pr

\zl

t =t +i

-z

(6.80)

Figuur 6.13 toont deze bovengrens voor Pb voor een aantal interessante BCH codes met codedebiet R 1/2, voor een BPSK-gemoduleerd systeem over een Gaussiaans kanaal met p = Q[(2REb/No) 1 1, en Q(x)=

Jx

+

^Z

^

e - ádt

(6.81)

We merken dat bij een bitfoutprobabiliteit Pb = 10-5 een coding gain van 4 dB mogelijk is voor een bloklengte 511.

6.12 Concatenatie van codes Concatenatie van codes is een praktische methode om een code te bekomen met een zeer lange bloklengte en het vermogen om een groot aantal fouten te kunnen corrigeren, zonder de implementatiecomplexiteit v an de code op te drijven. Concatenatie van codes betekent dat we op meerdere niveaus codering toepassen. Meestal gebruikt men slechts twee niveaus van codering. Men kan twee types concatenatie onderscheiden: seriële concatenatie en parallelle concatenatie. Bij seriële concatenatie (figuur 6.14) wordt de uitgang van de buitenste encoder gecodeerd door de binnenste encoder. Dit is in tegenstelling met parallelle concatenatie (figuur 6.15), waar beide encoders dezelfde informatiestroom coderen. In dit hoofdstuk beschouwen we enkel seriële concatenatie. In de praktijk worden Reed-Solomon codes veelal gebruikt als één van de codes bij seriële concatenatie, namelijk als de buitenste code. Als binnenste code kunnen verschillende types codes gebruikt worden. Het basisprincipe van seriële geconcateneerde codes met twee niveaus wordt getoond in figuur 6.16. Voor alle eenvoud veronderstellen we dat het kanaal een binair kanaal is, nl. er gaan bits in en er komen bits uit. De buitenste code is een niet-binaire code die gebruik maakt van symbolen die K bits voorstellen. Deze symbolen worden aangelegd aan de buitenste code. De buitenste code is een (n, k) blokcode met een bloklengte n, waarvan k symbolen informatiesymbolen zijn. De K-bits symbolen die uit de buitenste encoder komen, worden verder gecodeerd met behulp van de binnenste encoder. In de binnenste encoder worden N — K pariteitsbits toegevoegd, zodat de bloklengte van de binnenste 167

– – ongecodeerd e— (n k,t)= (7,4,1) --e– (n k,t)= (15,7,2) (n k,t)= (31,16,3) (n k,t)= (63,30,6) (n k,t)= (127,64,10) –e-- (n k,t)= (255,123,19)

1.E+00

--

1.E-01

–^ –

--

+^

1.E-02

(nx,k,t)=(511,259,28) 1.E-03 Pb ^

1.E-04

^ ►^^

''

1.E-05

1.E-06

1.E-07

IIIO

hIiu , ^

......

^^

^

I

^^

.. ...

3 4 5 6 7 8 9 10 11

0

.

12

Eb/No (dB)

Figuur 6.13: Performantie van BCH codes met BPSK modulatie

informatiebits encoder I —>

7E1

—> encoder 2 TE ; =

7rk -1

—>

codebits encoder k H-->

interleaver

Figuur 6.14: Seriële concatenatie van codes

168

informatiebits

encoder 1 I---->

encoder 2 H

codebits

nk -1

encoder k H

^

7Ci =

interleaver

Figuur 6.15: Parallelle concatenatie van codes

data in K

data uit superkanaal

PbIK

T

buitenste encoder (n,k)

—!^

binnenste N encoder

kanaal

N

binnenste decoder

K buitenste Ps decoder

(N,K)

Figuur 6.16: Seriële concatenatie van codes met twee codes code N wordt. Deze N bits worden dan parallel-naar-serieel geconverteerd en één na één verstuurd over het binaire kanaal. Aan de ontvangerzijde wordt een beslissing genomen over de data die verstuurd werd over het kanaal. De binnenste decoder levert een schatting van de K-bits symbolen af aan de buitenste decoder, aan een gemiddeld lage symboolfoutprobabiliteit p,. De buitenste decoder corrigeert dan zoveel mogelijk fouten, waardoor de resulterende bitfoutprobabiliteit Pb zeer laag wordt. De combinatie van de binnenste encoder, het kanaal en de binnenste decoder noemt men ook het superkanaal. Op dezelfde manier noemt men de combinatie van de binnenste en buitenste encoder de superencoder, en de combinatie van de binnenste en buitenste decoder de superdecoder. Merk op dat de bloklengte van de concatenatie van de twee codes gegeven is door N* = nN bits, met K* = kK informatiebits per codewoord en een codedebiet R* = rR = kK/nN, waarbij r = k/n en R= K/N. Hoewel de totale lengte v an de code gelijk is aan N* = nN, zal de decodering uitgevoerd kunnen worden met twee decoders met lengte N en n. Dit betekent dat de concatenatie van twee codes ervoor zorgt dat er een duidelijke vermindering van complexiteit is in vergelijking met een code met slechts één niveau, die dezelfde bitfoutprobabiliteit heeft als de geconcateneerde code. Meestal

169

gebruikt men Reed-Solomoncodes als de buitenste code, aangezien dit goede codes zijn en zeer eenvoudig te implementeren zijn. Indien de buitenste code een t-foutencorrigerende Reed-Solomoncode is, en de binnenste decoder symbolen levert met een symboolfoutprobabiliteit p5 , dan zal de bitfoutprobabiliteit aan de uitgang van de buitenste decoder gegeven zijn door 2 K -1

Pb < 2K — 1

n

j + t /n

L—d

\7

j =t+ 1

ps(1 — ps) n

—

j

(6.82)

.

Deze vergelijking is zeer gelijkaardig aan (6.80), maar bevat een extra factor 2K -1 /(2K — 1) om het gemiddeld aantal bitfouten per symbool in rekening te brengen. De performantie van een geconcateneerde code kan men bepalen door de symboolfoutprobabiliteit ps te schatten voor de gebruikte binnenste code, en daarna Pb te berekenen met behulp van (6.82). In veel gevallen zullen de symboolfouten die optreden na de binnenste decoder in groepjes komen, m.a.w. een hele periode zal de binnenste decoder correcte symbolen afleveren aan de buitenste decoder, en dan plots zullen verschillende fouten na elkaar optreden. Men spreekt hier v an burst-fouten. De buitenste code, de Reed-Solomoncode, kan de vele fouten die in de burst optreden veelal niet verbeteren, zodat de resulterende bitfoutprobabiliteit hoger zal liggen dan in het geval waar de fouten ongecorreleerd zijn, met dezelfde gemiddelde symboolfoutprobabiliteit p,. Merk op dat in dit laatste geval de bitfoutprobabiliteit gegeven is door (6.82). Een oplossing voor dit probleem is interleaving. De interleaver herschikt de symbolen die binnenkomen op een deterministische wijze, en heeft als uitgang een sequentie v an de aan gelegde symbolen, maar in een andere volgorde. De inverse bewerking wordt uitgevoerd met de deinterleaver, die de herschikte sequentie v an symbolen terugbrengt in zijn oorspronkelijke volgorde. Men plaatst de interleaver tussen de buitenste en de binnenste encoder, en de deinterleaver tussen de buitenste en de binnenste decoder, zoals in figuur 6.17. Aan de uitgang van de binnenste decoder kunnen burst-fouten optreden. Echter, door de interleaving zullen deze fouten aan de ing an g van de buitenste decoder niet meer na elkaar optreden, m.a.w. de interleaver decorreleert de burstfouten. Op deze manier wordt de kans klein dat de buitenste decoder symbolen met veel fouten ontvangt die hij niet kan corrigeren, en zal de werkelijke bitfoutprobabiliteit de theoretische uitdrukking (6.82) goed benaderen.

170

data in buitenste encoder (n,k)

binnenste

interleaver

encoder (N,K) kanaal

data uit buitenste f— decoder

F

deinterleaver

4-

binnenste

decoder

Figuur 6.17: De interleaver

171

t--

Hoofdstuk 7 Convolutionele codes 7.1 Inleiding In de vorige secties hebben we lineaire blokcodes behandeld. In blokcodes worden de informatiebits gegroepeerd in blokken van k bits, die dan onafhankelijk van elkaar gecodeerd worden in codewoorden van n bits. De gecodeerde sequentie word zo een sequentie van codewoorden met vaste lengte die onafhankelijk zijn van elkaar. Convolutionele codes verschillen van blokcodes in die mate dat de encoder van een convolutionele code geheugen bevat, zodat de n uitgangen van de encoder niet enkel afhangen van de k ingangen, maar ook van de K — 1 vorige informatieblokken van k bits. Daarom zal de de structuur van een convolutionele code complexer zijn dan de encoder van een blokcode, en zijn convolutionele codes moeilijker te analyseren. Echter, convolutionele codes zijn wel eenvoudig te encoderen en decoderen. Bij blokcodes zijn de algebraïsche eigenschappen zeer belangrijk bij het construeren van goede codes en bij het vinden van efficiënte decodeertechnieken. Dit is niet het geval bij convolutionele codes. Er bestaat geen algebraisch decodeeralgoritme voor convolutionele codes. Echter, er bestaan wel verschillende efficiënte decodeertechnieken voor convolutionele codes. De basis van deze decodeertechnieken is het decoderen van het ontvangen bericht met één bit tegelijkertijd, zonder het volledige bericht te moeten decoderen.

7.2 Encodering van convolutionele codes 7.2.1 Schuifregister en generatorsequenties Een convolutionele encoder met constraint lengte K bestaat uit een schuifregister met m = kK geheugenelementen, n modul o- 2 optellers en een parallel-naar-serieel omzetter om de uitgang van de encoder om te zetten in één enkele codesequentie (figuur 7.1). De constraint lengte is gelijk aan het aantal verschuivingen van k bits tijdens hetwelk een 172

kK=m geheugenelementen .4

blok 0

blok 1

blok K-1

k informatiebits

n modulo-2 optellers P/S

gecodeerde sequentie Figuur 7.1: Convolutionele encoder informatiebit de uitgang v an de encoder kan beïnvloeden, en wordt ook het geheugen van de code genoemd. De informatiebits worden in het schuifregister ingelezen met k bits tegelijk; alle bits in het schuifregister worden k plaatsen naar rechts verschoven, en de uitg angen van de optellers ondergaan een parallel-naar-serieel-conversie. De resulterende sequentie van codebits wordt d an verstuurd over het kanaal. Aangezien er n codebits zijn per groep van k informatiebits, is het codedebiet gelijk aan = k/n. In deze sectie gaan we vier verschillende benaderingen beschouwen voor de encoder: (1) encodering met behulp van schuifregister en generatorsequenties, (2) encodering met behulp van discrete convoluties, (3) encodering met behulp van scalaire matrices, en (4) encodering met behulp van veeltermen. Een convolutionele code met constraint lengte K en debiet R = k/n kan worden beschreven aan de hand van k generatorsequenties: ,

p

U)

^J) ( gi 3 O o

(.7) ..., g CJ) iK-1) ,

gi^1^

(7.1)

orsequenties geven a an en9i91 9,91..)) E {0, 1}. Deze waarbij i = 1, 2, ... , k, j = 1, 2, ... , n en o2 optellers verbonden zijn, welke geheugenelementen in het schuifregister met welke modul en kunnen rechtstreeks afgeleid worden uit het schuifregister. Indien g t = 1, dan is er een verbinding tussen de het ide geheugenelement in het B-de blok van k geheugenelementen met de jde modul o- 2 opteller, en als g é) = 0, dan is er geen verbinding. Deze sequenties kunnen ook genoteerd worden als veeltermen met graad K — 1:

(.7) gi (x) = gi3O

(i) + ... + (i) (.i) gi,lx gi,K-1 x K-1 .

173

(7.2)

informatiebits

Figuur 7.2: Encoder voor de (2,1) convolutionele code met

K=3

Het verband tussen de informatiesequentie bei) = (bo x) , blZ) ...), (i = 1, 2, ... , k) en de gecodeerde sequentie c (i) = (con) , c^ ) .. . , (j = 1, 22,, . , n) is gegeven door de discrete convolutie van de informatiesequentie met de generatorsequentie: ,

k

CU) =

(à), E b(i) ® gg(j),

(7.3)

i=1

of c(i)

_

K-1

[ k

V O
E E bá2? e9ié

e-o i=1 Door deze convolutie bij de encodering komen de convolutionele codes aan hun naam. Voorbeeld 1 (Encodering met behulp van schuifregister en generatorsequenties): Een eenvoudig voorbeeld is de R c = 1/2 convolutionele encoder voor een (2,1) code met m = 3, die getoond wordt in figuur 7.2. Aangezien m = 3 en n = 2 bestaat deze encoder uit een schuifregister met 3 geheugenelementen, 2 modulo-2 optellers en een multiplexer om de twee uitgangen van de encoder om te vormen in het codewoord. Voor de encoder getoond in figuur 7.2 zijn de generatorsequenties gegeven door g (i l) = (g'ó, 9111, gi12) = (101) en g 12) (2) 1,1 (2) = (91,0 ^ 9i,i , 91,2) = ( 111.) Gebruik makend van (7.4) ( ) voor i = 1 en j = 1, 2 bekomen we de vergelijkingen c\

= " A 9i ó + "A-191,1 + b ^1^ 29i2

A

= M 1) 91,ó + bá1 191,1 + b á-291,2•

C

Substit

van gll) = (101) en g12) = (111) levert de vergelijkingen l) + bá1)2 A = bA cá2) = b1,1) +e1 + b(A1) 2.

C (1)

174

(7.4)

We beschouwen een informatiesequentie van lengte L = 5 b(1 ) = (10011). Dan kan de codesequentie voor 0 < A < 6 bekomen worden als volgt: A

0 col) = 41) = 1 1 c(i i) =bil) = 0 1) = b21) + b(01) 2 =0+1=1 3c31) = b31) + b11) = 1+0=1 4 4 c( 1) = b41) + b21) = 1+0=1 5 c51)=b31)=1 6

c(6l) =b41, = 1

cA(' ) j = 1, 2 , cot) = bol) =

1 c12) = b1 l) + bó1) = 1 c( 2) = b(21) + 141) + b0( 1) 2 = 0+0+1=1 C32) = b31) + b21) + bil) ,

c42)

=1+0+0=1 b41) + b31) + bil) = 1+1+ 0= 0

—

4( 1) +b31) =1+1=0 c52) =b

c62) =b41)- 1

( c (A1) , c(2) ) a (1,1) (0 , 1 ) (1,1) ( 1 1) (1,0) (1,0) (1,1)

De twee uitgangen van het schuifregister ( cl , c(2) ) worden gemultiplexeerd tot een enkele sequentie. Het resulterende codewoord is gegeven door C2), ( 1) 0 cl cl(2) , (1) C6 ( 2) C= ^l )

(41)

(

...,

c6 )

= (1 1, 0 1, 1 1, 1 1,1 0,1 0, 1 1). Voorbeeld 2 (Encodering met behulp van convolutie): Beschouw opnieuw de encoder uit figuur 7.2. De generatorsequenties zijn gll) = (101) en g12) = (111), en de informatiesequentie is b( 1) = (10011), zoals in het vorige voorbeeld. De codesequentie kan ook bekomen worden door de volgende convoluties uit te voeren: c(1)

= b(1) ®gi ) = (10011) ® (101) = (1011111)

c(2)

_

=

b(1) ®g12)

(10011) ® (111) = (1111001).

Het resulterende codewoord wordt bekomen door deze twee sequenties te multiplexeren: c = (1 1,01,11,1 1,1 0,10,1 1). We bekomen dus hetzelfde codewoord met de twee encodeermethodes. 7.2.2

Generatormatrix

Beschouw een (n, k) convolutionele code met m geheugenelementen. Indien een willekeurige (A informatiesequentie b = (b0 , b1 , b2 , ... , ), waarbij bA = (bal) , b 2) , ... , bak) ), A = 07172, .. . 175

ingevoerd wordt in de encoder, dan is de codesequentie c = (co , cl, c2i ... , ), waarbij cA = als cr ... cans ) A = 0, 1, 2, ..., gegeven door de volgende matrixvergelijking:

(c

,

,

,

,

c = bG. De

(7.5)

structuur van de semi- oneindige generatormatrix G gegeven is door:

/ Go G1 G2 G

=

0 0

...

Go G1 G2 0 Go G1

GK-1

0

...

GK_1

0 0

0 0

G2

...

GK-1

0

•

(7.6)

Elke submatrix Ge (€ = 0,1, 2, ... , K —1) heeft k rijen en n kolommen Elke set van k rijen van G is gelijk aan de vorige set van k rijen, maar n kolommen verschoven naar rechts. De k x n submatrix Ge in G is gegeven door / 91,e 9 i e Ge =

92,1

(2) 92,1

l

9k e 9k e

9 9

ié z1

(7.7)

9k e f

Uit deze notatie volgt dat een convolutionele code equivalent is met een semi-oneindige lineaire blokcode. Voorbeeld 3 (Encoderen met behulp van scalaire matrices): Beschouw opnieuw de encoder getoond in figuur 7.2. De eerste rij (G o , G 1 , G2 ) = (110111) van G wordt bekomen door g( 1) _ (101) en g(2) = (111) met elkaar te vervlechten, of het substitueren van g(1) en g(2) volgens (7.7). Indien de informatiesequentie b = (10011) gegeven is, dan bekomen we het codewoord c = bG

/ 11 01 11 11 01 11 = (10011)

= (1 1, 0 1,1

1 1 01 11 11 01 11

11 01

11

1,1 1,1 0,1 0,1 1),

wat overeenkomt met de resultaten van de vorige twee voorbeelden. Merk op dat elke rij (k = 1) van G overeenkomt met de voorgaande rij, maar verschoven naar rechts over n = 2 kolommen

176

7.2.3 Veeltermnotatie Voor het encoderen van convolutionele codes met behulp van veeltermen merken we op dat, aan gezien een convolutionele encoder een lineair systeem is, elke sequentie in de codevergelijkingen kan vervangen worden door zijn corresponderende veelterm, en dat de convolutie kan vervangen worden door veeltermvermenigvuldiging. De informatiesequentie b(i) = (b , blt) , b2t) , ...), i = 1, 2, ... , k kan worden voorgesteld door de veelterm

ot)

b(t) (x) = bot) + b(It) x + 4i) x2 + ... ,

(7.8)

en de codesequentie c (i) = (con) , c(1.) , c(2.1) , ...), j = 1, 2, ... , n door de veelterm c(i) (x) = col ) + c ^) x + 4x2 + ....

(7.9)

De generatorveelterm van de code ; ) x + 9i,2 (' ) x2 + ... 0 9i (x) = 9 ^ ) +9i1

(7.10)

met i = 1, 2, ... , k en j = 1, 2, ... , n, is de transfertfunctie die de ingang i verbindt met de uitgang j. Merk op dat de parameter x een vertraging voorstelt. Indien we een systeem met k ingangen en n uitgangen beschouwen, dan kan de encoder beschreven worden door een k x n generatormatrix, waarbij de elementen bestaan uit kn generatorveeltermen: 9(1) (x)

921) (x)

G(x) =

912)(x)

...

922)(x)

...

9 n)(x) g (x)

2n) (

(7.11)

91)(x) 9(2)(x) ... 9kn) ( ) De codevergelijking voor de = k/n convolutionele code met geheugen m kan dan worden geschreven als k

CU)(x) _

E b (t) (x)9 i=1

) (x),

j = 1, 2, ... , n,

(7.12)

waarbij de convolutie vervangen is door veeltermvermenigvuldiging. In het algemeen kunnen de codevergelijkingen geschreven worden als c'(x) = b(x)G(x),

(7.13)

waarbij b(x) = (b(l ) (x), b( 2) (x), ... , b(k) (x)) voor de informatiesequentie en c'(x) = (c(1) (x), c (2) (x), ... , c(n) (x)) voor de codesequentie. Na multiplexering bekomen we het codewoord: (7.14) c x = c (l) (xn ) + xc(2) (xn ) + . . . + xn-lc(n)(xn). (

)

177

Voorbeeld 4 (Encoderen met behulp van veeltermen): Beschouw de (2,1) convolutionele code met m = 2 waarvan de encoder getoond wordt in figuur 7.2. De generatorveeltermen zijn gi' ) (x) = 1+x 2 en gi2) (x) = 1+ x+x2 . Hieruit volgt dat de code gekarakteriseerd wordt door een 1 x 2 generatorveeltermmatrix G(x) = (1 + x 2 ,1 + x + x2 ). Voor de informatiesequentie b(x) = 1 + x3 + x4 wordt de encodering uitgevoerd als volgt:

c'(x)

= b(x G(x)

_

)

= ( 1 +x3 + x 4 ) 1+ x2 , 1+ x +x2 ) (

(1 + x2 + x3 + x4 + x5 + x6 , 1 + x + x2 + x3 + x6 ) (c(' ) (x), c (2) (x)).

Hieruit volgt dat de codesequentie aan de uitgang van de encoder gegeven is door C(x)

C (1) (x2 ) + xc (2) (x2) = 1+x4 +x6 +x$ +x10 +x12 +x(1+x2 +x4 +x6 +x 12 ) =

= 1+ x +x 3 +x4 +x5 +x6 + x 7 +x$ + x 10 +x 12 +x13 , zodat we het volgende codewoord bekomen c = (1 1, 0 1,1 1,1 1,1 0,1 0,1 1),

wat correspondeert met het codewoord gevonden met de andere methodes.

7.3

Grafische voorstelling van convolutionele codes

Een convolutionele code is een eindige toestand machine, wat de algemene naam is van een systeem met geheugen. Het adjectief eindig slaat op het feit dat het systeem zich slechts een eindig aantal toestanden kan bevinden. De toestand van een systeem is de kleinste hoeveelheid informatie die, tezamen met de ingang van het systeem de uitgang van het systeem k an voorspellen. De toest an d geeft informatie over de voorbije gebeurtenissen en de beperkte set v an mogelijke uitkomsten in de toekomst. Bij een (n, k) convolutionele encoder bestaat de toestand uit de k(K — 1) laatste informatiebits. De kennis van de toestand samen met de kennis van de volgende ingang is een nodige en voldoende kennis om de volgende uitgang van het systeem te bepalen. We definiëren de toestand op een tijdstip t i als Xi = bi _ k , bi_k_ ii ... , bi_ kK . De ide uitgang Ui van de encoder wordt op een unieke wijze bepaald door de toest an d Xi en de huidige ingang bi bi _1 ... , bi-k+1; dit betekent dat bij het encoderen de toestand X i de voorbije gebeurtenissen in de encoder ,

178

,

voorstelt. We kunnen de toestand van de encoder beschrijven als een Markov-proces, aangezien de kans P(X i+1 IXi , Xi_ 1 , ... , Xo ) dat de toestand Xi+1 optreedt gegeven alle vorige toestanden, enkel afhangt van de meest recente toestand X i m.a.w. de kans is gelijk aan P(Xi+1|Xi) ,

Voorbeeld: Beschouw de convolutionele encoder uit figuur 7.2. We veronder-

stellen dat de encoder geïnitialiseerd is met nullen. De informatiesequentie is gelijk aan b = (11011), aangevuld met K — 1 = 2 nullen om het schuifregister terug in de nultoestand te brengen. Het codewoord wordt gevormd als volgt:

ingangsbit bi -

1 1 0 1 1 0 0

inhoud encoder 000 100 110 011 101 110 011 001

uitgang toestand toestand encoder op tijdstip op tijdstip op tijdstip ti

ti+1

c1

c2

00 00 10 11 01 10 11 01

00 10 11 01 10 11 01 00

1 1 1 0 1 1 1

1 0 0 0 0 0 1

ti

Hieruit volgt dat het codewoord gegeven is door c = 11101000101011. In bovenstaand geval hebben we verondersteld dat het schuifregister geïnitialiseerd was met nullen. Dit is equivalent met de voorwaarde dat de informatiesequentie wordt voorafgegaan door twee nullen (de uitgang van de encoder is een functie van de huidige bit en de k(K — 1) voorgaande bits). We herhalen het encodeerproces w an neer de gegeven informatiesequentie wordt voorafgegaan door twee enen. Indien de bit niet gekend is duiden we dit a an met X. We bekomen uit de onderstaande tabel dat het codewoord c = 01011000101011. Vergelijken we dit met het codewoord indien het schuifregister geïnitialiseerd is met nullen, dan observeren we dat de codewoorden verschillen. Hiermee wordt duidelijk gedemonstreerd dat de uitgang van de encoder niet enkel afhangt van de ing an g, maar ook van de k(K — 1) voorgaande bits.

Er besta an drie alternatieve methodes om een convolutionele code grafisch te beschrijven, gebaseerd op de toestand van de encoder: de boomstructuur, het traliediagram en het toestandsdiagram. De boomstructuur voor de convolutionele encoder uit figuur 7.2 wordt getoond in figuur 7.3. De boomstructuur geeft de overgangen weer tussen de verschillende 179

ingangsbit inhoud bi encoder 1

11X ill

1 0 1 1 0 0

111 011 101 110 011 001

-

uitgang toestand toestand encoder op tijdstip op tijdstip op tijdstip ti ti Cl 4+1 C2 1X

11

11 11 11 01 10 11 01

11 11 01 10 11 01 00

-

0 0 1 0 1 1 1

1 1 0 0 0 0 1

toestanden als functie van de tijd. We veronderstellen dat de encoder initieel in de nultoestand is (de geheugenelementen in de encoder bevatten nullen). Op elk tijdstip splitst elke toestand zich op in twee takken, corresponderend met de twee mogelijke ingangen van de encoder. Indien de ingangsbit '0' is, dan wordt de bovenste tak gekozen, en als de ingangsbit '1' is, de onderste tak. Bij elke tak wordt de uitg an g van de encoder weergegeven, die correspondeert met de toestand waarin de encoder zich bevond en de ingang van de encoder, en de nieuwe toestand van de encoder. De encodering van een informatiesequentie kan beschreven worden door de boomstructuur te doorlopen van links naar rechts. Indien de eerste informatiebit '0' is, dan toont de boomstructuur dat de uitgang v an de encoder 00 is, en als de eerste informatiebit '1' is, dan is de uitgang van de encoder 11. Verder, indien de eerste informatiebit '1' is en de tweede '0', dan is de tweede uitgang van de encoder 01, of, indien de eerste en de tweede informatiebit beide '1' zijn, dan is de tweede uitgang van de encoder 10. Indien we deze procedure toepassen op de informatiesequentie 11011, dan zien we dat het pad dat doorlopen wordt in de boomstructuur gegeven wordt door de dikke zwarte lijn in de figuur, en dat de corresponderende uitgang van de encoder gegeven is door de sequentie 1110100010. De tijdsdimensie in de boomstructuur laat toe de encoder te beschrijven op een dynamische wijze als functie v an een bepaalde informatiesequentie. Echter, zoals reeds merkbaar is in figuur 7.3, is het probleem bij het gebruiken van de boomstructuur dat het aantal takken exponentieel toeneemt in de tijd: het aantal takken in het voorbeeld is 2", waarbij L de lengte van de informatiesequentie is. Dit toont aan dat de boomstructuur niet bruikbaar is in praktische situaties. Indien we de boomstructuur in figuur 7.3 bestuderen, dan zien we dat in dit voorbeeld dat de structuur op tijdstip t 4 zich herhaalt (in het algemeen zal de structuur zich herhalen na K tijdstippen, waarbij K de constraint lengte is). We benoemen elk knooppunt in de boomstructuur in figuur 7.3 corresponderend met de vier mogelijke toestanden van de encoder: a = 00, b = 10, c = 01 en d = 11. Op het eerste tijdstip t 1 worden er twee knooppunten gegenereerd, corresponderend met de toestanden a en b. Bij elk volgend tijdstip verdubbelt het aantal knooppunten. Op het tweede tijdstip t 2 zijn er vier knoop180

00

000 a

00 a

01

11 b

00 01

c

11 b

uitgang encoder

d

01 00

a

11 a

01

toestand encoder

c

b b

10 11

10 10 d

c

d

00

1 11 a

00 10

01

a

01

1 01

00

ii

01 00

a

11 01

11 b

c

10 11

01 00

b

c

00 101

10 d

11 b

01 00

11 a=00 b=10 c=01 d=11

00 10

]0

00

1

10 11

a

informatiebit

11

a

11

10 c

01

00 b

10 d

11 10 01

d

c

t2

t3

00 10

01 d

t1

10

ta

01 t5

Figuur 7.3: Boomstructuur voor de R, = 1/2, K = 3 encoder 181

t2

t^

toestand a=00

00

t3

00 _

t5

tq

00

_

00

t6

00

b=10 .

c=0I

d=11 .

ingangsbit 0 ingangsbit 1

Figuur 7.4: Traliediagram voor de Re = 1/2,

K = 3 encoder

punten corresponderend met de toestanden a, b, c en d. Na het derde tijdstip zijn er acht knooppunten: tweemaal a, tweemaal b, tweemaal c en tweemaal d. We observeren dat alle takken voortkomend uit dezelfde toestand dezelfde uitgangen hebben. Vanaf dit punt zijn de bovenste en de onderste helft van de boom gelijk. De reden wordt duidelijk na observatie van de encoder uit figuur 7.2: wanneer de vierde informatiebit wordt ingelezen in de encoder, wordt de eerste informatiebit van de sequentie uit de encoder verwijderd, en kan dit bit de uitgang v an de encoder niet meer beïnvloeden. Hieruit volgt dat de ingangssequenties 100xy ... en 000xy ..., waarbij de linkse bit de eerste bit in de sequentie voorstelt, hetzelfde codewoord genereren na het K = 3de tijdstip. Dit betekent dat twee knooppunten met dezelfde toestand op het tijdstip t; kunnen samengenomen worden, aangezien alle paden die uit deze toestanden vertrekken niet van elkaar kunnen onderscheiden worden. Indien we dit toepassen op de boomstructuur uit figuur 7.3, dan bekomen we een traliediagram (ook trellisdiagram genoemd). Het traliediagram maakt gebruik van de repetitieve structuur, en is praktischer in gebruik dan de boomstructuur bij het beschrijven van de convolutionele code, aangezien het aantal takken niet exponentieel toeneemt zoals bij de boomstructuur. Het traliediagram voor de convolutionele code uit figuur 7.2 wordt getoond in figuur 7.4. Bij het tekenen van het traliediagram gebruiken we dezelfde conventie als bij de boomstructuur: de bovenste tak die uit een knooppunt vertrekt (de volle lijn) correspondeert met een informatiebit '0', en de onderste tak (de gestreepte lijn) met een informatiebit '1'. De knooppunten van het traliediagram stemmen overeen met de toestanden van de encoder; de eerste rij knooppunten stemmen overeen met de toestand a = 00, de tweede en volgende rijen stemmen overeen met de knooppunten b = 10, c = 01 en d = 11. Op elk tijdstip heeft het traliediagram 2kix-1} knooppunten nodig om de 2k( x-1) toestanden voor te stellen. In elke toestand komen 2 k takken toe en vertrekken 2 k takken (na de initiële overgangsfase). In het voorbeeld bereikt het traliediagram de repetitieve structuur

182

na drie tijdstippen (op t 4 ) (in het algemeen zal de repetitieve structuur bereikt worden na K tijdstippen). Vanaf dit punt kan elke toestand bereikt worden vanuit twee toestanden. Verder kunnen vanaf dit punt vanuit elke toestand twee toestanden bereikt worden. Van de vertrekkende takken stemt één tak overeen met ingangsbit '0' en één met ingangsbit '1'. In figuur 7.4 wordt bij elke tak de uitgang van de decoder aangegeven bij de transitie van een toestand naar een andere toestand. Door de takken te volgen die corresponderen met de ingangssequentie kan men het codewoord a fl ezen dat correspondeert met het pad in het traliediagram dat doorlopen wordt. Aangezien de uitgang van de encoder bepaald wordt door de ingang van de encoder en de toestand van de encoder kan een grafische voorstelling worden gebruikt die nog meer compact is dan het traliediagram - het toestandsdiagram. Het toestandsdiagram is een diagram met de mogelijke toestanden van de encoder, en de mogelijke overgangen - of transities - tussen de toestanden. Het toestandsdiagram voor de convolutionele code uit figuur 7.2 wordt getoond in figuur 7.5. Uit elke toestand vertrekken er twee verbindingen, corresponderend met de twee mogelijke ingangsbits. Naast elke verbinding staat de ingang van de encoder die aanleiding geeft tot, en de uitgang van de encoder die correspondeert met de overgang van de ene toestand naar de an dere toestand. Merk op dat het niet altijd mogelijk is met één enkele overgang van de ene toestand naar een andere toest an d te gaan. Door het invoeren van 1 bit per keer zijn er slechts twee mogelijke overgangen die het schuifregister kan maken. Bijvoorbeeld, indien de huidige toest an d van de encoder 00 is, dan zijn de enige mogelijke toest an den waarnaar het schuifregister kan overgaan door het invoeren van een bit gelijk a an 00 of 10. Uit het toestandsdiagram volgt dat de mogelijke overgangen gegeven zijn door: a —>a, a —> b, b —> a,

b-4c, c->b, c -4 d, d

-°-

b, d —>d,

waarbij a 13> a de overgang van toestand a naar a voorstelt indien de ingangsbit gelijk is aan '0'. Beschouw de convolutionele encoder uit figuur 7.6 met debiet = 2/3 , k = 2 en K = 2. In deze encoder worden twee informatiebits R^ tegelijkertijd ingelezen, en 3 codebits worden gegenereerd per verschuiving. De generatorsequenties zijn Voorbeeld:

g2) = (11) g22) = ( 10) g23 ^ = (11).

g1 = (01 ) gi2) = ( 11 ) g13) = (00)

We veronderstellen dat de encoder geïnitialiseerd is met nullen. De eerste twee ingangsbits kunnen 00, 01, 10 of 11 zijn. De corresponderende uitgangen zijn 000, 010, 111 en 101. Wanneer het volgende paar van bits wordt ingelezen, wordt het eerste paar van bits doorgeschoven naar het tweede blok 183

0/0 0

Figuur 7.5: Toestandsdiagram voor de Rc = 1/2,

K = 3 encoder

1 informatiebits

codebits

Figuur 7.6: Encoder voor de (3,2) convolutionele code met

k = 2 en K = 2

met geheugenelementen. De uitg an gen van de encoder op het tweede tijdstip hangen af van het paar v an bits dat in het tweede blok van het schuifregister zit en het nieuwe paar van bits. De boomstructuur voor deze code wordt getoond in figuur 7.7. Deze boomstructuur heeft vier takken per knooppunt, corresponderend met de vier mogelijke paren van ingangssymbolen. Aangezien de constraint lengte van de code K = 2 is, begint de boom zich te herhalen na twee tijdstippen. Zoals geïllustreerd wordt in figuur 7.7 hebben alle takken die voortkomen uit toestand a dezelfde uitgangen. Door alle knooppunten die dezelfde toestand voorstellen samen te nemen, bekomen we het traliediagram, getoond in figuur 7.8. Verder wordt het toestandsdiagram voor deze code getoond in figuur 7.9.

184

000 010 000 111 101

110

a=00 b=01 c=10 d=11

100 010 001 011

101 111 111

b 010 000

011 001 b

101 100 110

d

Figuur 7.7: Boomstructuur voor de Rc = 2/3, k = 2, K = 2 encoder

185

t2

ti

t3 000

toestand a=00

t4

t5

000

oio b=01

.

c=10

.

d=11

.

Ill

iol

Figuur 7.8: Traliediagram voor de Re = 2/3, k = 2, K = 2 encoder

moo

lino Figuur 7.9: Toestandsdiagram voor de Re = 2/3, k = 2, K = 2 encoder

186

7.4 7.4.1

Eigenschappen van convolutionele codes Afstandseigenschappen van convolutionele codes

Zoals bij de lineaire blokcodes is de Hammingstructuur van een convolutionele code van groot belang bij de performantie van de code. Aangezien een convolutionele code lineair is, zal de studie van de Hammingstructuur van de code zich herleiden tot de studie van de gewichtsstructuur van de code, zodat we mogen veronderstellen zonder verlies aan algemeenheid dat de nulsequentie wordt ingevoerd in de encoder. Bij convolutionele codes bestaat er echter, in tegenstelling tot lineaire blokcodes, geen intrinsieke bloklengte ten opzichte van hetwelk we de afstand of het gewicht kunnen meten. Een methode om de afstandseigenschappen van een convolutionele code te bekomen is via zijn toestandsdiagram. Het toestandsdiagram uit figuur 7.5 zal gebruikt worden om de methode te demonstreren om de afstandseigenschappen van een convolutionele code te bekomen. Eerst benoemen we elke verbinding van het toestandsdiagram met D ° = 1, D of D2 , waarbij de exponent van D de Hammingafstand a angeeft tussen de sequentie van uitgangsbits voor de verbinding en de sequentie van uitgangsbits voor de nulsequentie. De verbinding van toestand a naar zichzelf kan worden geëlimineerd, a angezien deze verbinding geen bijdrage levert aan de afstandseigenschappen van een codesequentie in vergelijking met de nulsequentie. Verder wordt de toestand a opgesplitst in twee toestanden: één die overeenstemt met de ingang van het toestandsdiagram, en één die overeenstemt met de uitgang v an het toestandsdiagram. Het gewijzigde toestandsdiagram wordt getoond in figuur 7.10. We gebruiken dit gewijzigd toestandsdiagram, dat vijf knooppunten bevat omdat toestand a in twee gesplitst is, om de vier toestandsvergelijkingen neer te schrijven:

D2Xa + X, X, = DXb + DX d d = DX b + DXd X X e = D2X,. Xb =

De transfertfunctie van de code is gedefinieerd als T(D) = Xe /Xa . Door de bovenstaande vergelijkingen op te lossen, bekomen we de transfertfunctie

T(D) =

D5

1-2D = D5 +2D6 +4D7 +8D8 +•••

(7.15)

00

= > 2d-5 Dd d=5 De transfertfunctie voor deze code geeft aan dat er één pad is op Hammingafstand d = 5 van het nulpad dat samenkomt met het nulpad op een bepaald tijdstip. Uit het toestandsdiagram getoond in figuur 7.5 of het traliediagram in figuur 7.4 kan worden afgeleid dat 187

Figuur 7.10: Gewijzigd toestandsdiagram voor de R, = 1/2, K = 3 encoder dit pad met d = 5 gelijk is aan abce. Er bestaat geen enkel ander pad van knooppunt a naar knooppunt e met Hammingafstand d = 5. De tweede term in (7.15) geeft aan dat er twee paden zijn van knooppunt a naar knooppunt e met Hamminggewicht d = 6. Opnieuw kunnen we uit het toestandsdiagram of het traliediagram afleiden dat deze paden abdce en abcbce zijn. De derde term in (7.15) duidt aan dat er vier paden zijn met Hammingafstand d = 7, enzovoort. Dit betekent dat de transfertfunctie v an een convolutionele code ons de afstandseigenschappen levert van de code. De minimale afstand van de code wordt minimale vrije afstand genoemd en genoteerd als d f Tee . In het voorbeeld is d f 9ee = 5. De transfertfunctie kan gebruikt worden om meer gedetailleerde informatie te bekomen dan enkel de afstandseigenschappen v an de codewoorden. Stel dat we een factor N t oevoegen aan alle verbindingen die veroorzaakt worden door de informatiebit '1'. W an neer men de verschillende paden afloopt, zal de cumulatieve exponent van N verhoogd worden met 1 wanneer een verbinding wordt veroorzaakt door de informatiebit '1'. Verder intr oduceren we voor elke verbinding in het gewijzigde toestandsdiagram de factor J, waarbij de exponent v an J aangeeft hoeveel knooppunten doorlopen werden bij een gegeven pad van knooppunt a naar e. Voor de convolutionele code uit figuur 7.2 wordt het gewijzigde toestandsdiagram met de factoren N en J getoond in figuur 7.11. De toestandsvergelijkingen voor het gewijzigde toestandsdiagram in figuur 7.11 zijn gegeven door

Xb = X, = Xd = e =

JND2X Q + JNX, JDX b + JDXd JNDXb + JNDX d JD2X e . X

Door de bovenstaande vergelijkingen op te lossen, bekomen we de transfertfunctie

188

JND

7.11: Gewijzigd toestandsdiagram voor de R, = 1/2, K = 3 encoder met de factoren N en J

Figuur

T(D, N, J) =Xe /X Q T(D, N, J)

D5 NJ3 1 — JND(1 + J) = D5 NJ3 + D6 N 2 (J4 + J5 ) + D7N 3 (J5 + 2J6 + J7 ) +D8 N4 (J6 +3J7 +3J8 +J8 )+••• .

(7.16)

Deze vorm van de transfertfunctie geeft ons alle eigenschappen van de paden in de convolutionele code. Dit is, de eerste term in de exp an sie van T(D, N, J) geeft a an dat het pad met Hammingafstand d = 5 van lengte 3 is, en dat van de drie informatiebits die a an leiding geven tot dit pad er slechts één gelijk is aan '1'. De tweede term in (7.16) geeft aan dat er twee paden zijn met Hammingafstand d = 6, één pad met lengte 4 en één pad met lengte 5. In het pad met lengte 4 zijn er twee van de vier informatiebits gelijk a an '1', en in het pad met lengte 5 zijn twee van de vijf informatiebits gelijk aan '1'. Dus, de exponent van J geeft de lengte van het pad, dat voor de eerste keer terug samenkomt met het nulpad, de exponent van N geeft het aantal informatiebits gelijk aan '1' voor dit pad, en de exponent van D geeft de afstand van het resulterende codesequentie tot de nulsequentie. De exponent van J is bel an grijk in het geval we een informatiesequentie met eindige duur (L bits) wensen te versturen. In dit geval wordt de convolutionele code afgebroken na L tijdstippen. Dit impliceert dat de transfertfunctie van de afgebroken code kan bekomen worden door de transfertfunctie T(D, N, J) af te breken bij de term JL . Aan de andere kant, indien we een zeer lange sequentie wensen te versturen, d.i. een quasi-oneindige sequentie, d an willen we de invloed v an J op T(D, N, J) uitschakelen. Dit kunnen we doen

189

door J = 1 te stellen in T(D, N, J). Voor de transfertfunctie (7.16) bekomen we dan: D5N 1 — 2ND = D5 N + 2D6N 2 + 4D7 N3 + 8D8N4 + • • •

T(D, N,1) = T(D, N) =

E2 co

d-5 N d-4 Dd

d=5

7.4.2

Catastrofale codes

Sommige convolutionele codes vertonen een eigenschap die catastrofale foutpropagatie noemt. Wanneer een code met deze eigenschap over een binair symmetrisch kanaal wordt gebruikt, is het mogelijk dat een eindig aantal kanaalfouten aanleiding geeft tot een oneindig aantal decodeerfouten. Zo een catastrofale code kan worden geïdentificeerd aan de h an d van het toestandsdiagram: het toestandsdiagram zal een pad met uitgangsgewicht nul (een pad met factor D° = 1) van een niet-nultoestand naar zichzelf bevatten. Dit betekent dat men dit pad met uitgangsgewicht nul oneindig keer kan doorlopen zonder het gewicht ten opzichte van het nulpad te vergroten. Indien dit pad met uitgangsgewicht nul correspondeert met de transmissie van de informatiebit '1', d an is het mogelijk dat de decoder een oneindig aantal decodeerfouten introduceert. Deze oneindige foutpropagatie moet vermeden bij het ontwerpen van een code. Als G(x) de k x n matrix met generatorveeltermen van de code voorstelt, dan geldt dat de code geen catastrofale code is indien de determinanten v an alle k x k submatrices uit G(x) als grootste gemene deler xl, B > 0 hebben. Deze voorwaarde is een nodige en voldoende voorwaarde opdat een convolutionele code geen catastrofale code is. Voorbeeld: Beschouw de encoder uit figuur 7.12, waarbij ook het toestandsdiagram wordt getoond. Uit het toestandsdiagram leiden we af dat de lus van toestand (11) naar zichzelf een uitgangsgewicht nul heeft, zodat de code catastrofaal is. Anderzijds, de generatorveeltermen zijn gelijk aan gl1) (x) = 1 + x en g i2) (x) = x + x2 . Aangezien k = 1 moeten we de grootste gemene deler van alle generatorveeltermen bepalen. Beide veeltermen bezitten een gemeenschappelijke factor 1+ x, zodat opnieuw volgt dat de code een catastrofale code is. Indien we de informatiesequentie (11111...) zouden coderen, dan bekomen we de sequentie 1001000000..., met gewicht 2. Hoewel de minimale vrije afstand van deze code d f ree = 4 is, wordt de performantie voor lange sequenties bepaald door het pad met gewicht 2. Dit betekent dat deze code niet gebruikt mag worden voor lange berichten wegens zijn potentieel voor catastrofale foutpragie.

190

informatiebits

0/00

1/00 Figuur 7.12: Encoder en toestandsdiagram voor een R, = 1/2, in = 2, n = 2 catastrofale

code

191

7.4.3

Grenzen op de vrije afstand van convolutionele codes

Zoals bij blokcodes kan men grenzen voor de minimale vrije afstand afleiden. Bovengrenzen voor de minimale vrije afstand voor convolutionele codes zijn eenvoudig te bekomen. Een eenvoudige bovengrens is: (7.17) dfree < Kn. Deze grens volgt uit het feit dat indien men een ingangssequentie heeft die verschilt v an an k informatiesymbolen (b0 0 0) men een codesequentie kan genereren nuliébokv met ten hoogste Kn codesymbolen verschillend van nul, wegens het geheugen K van de encoder (na K verschuivingen is het blok b0 verdwenen uit de encoder). Deze eenvoudige bovengrens is een zeer losse bovengrens (behalve voor het geval K = 1). Een betere bovengrens voor de minimale vrije afstand van een R, = 1/n convolutionele code wordt bekomen door gebruik te maken van de Plotkingrens uit sectie 5.3. Hiermee bepalen we een bovengrens voor de minimale afst and voor berichten van lengte L, gevolgd door k(K —1) nullen. De vrije afstand wordt bekomen door deze bovengrens te minimaliseren over alle waarden van L. In dat geval bekomen we de bovengrens 2L1 dfreeS min L2Lk _ 1 (K+L- 1)nj.

7.5

(7.18)

Decoderen van convolutionele codes - het Viterbi algoritme

Wanneer een codesequentie c verstuurd wordt over het kanaal, dan kan de ontvangen sequentie r fouten bevatten. Net zoals bij het optimale decodeeralgoritme bij lineaire blokcodes zoeken we het codesequentie die het dichtst bij de ontvangen sequentie ligt. Bij een codesequentie die overeenstemt met een informatiesequentie met lengte L zijn er dus 21' verschillende codewoorden die men moet testen. De complexiteit van deze optimale decoder is zeer groot, zodat alternatieve decodeeralgoritmes werden gezocht. Een alternatief decodeeralgoritme is het Viterbi decodeeralgoritme dat gebruik maakt van de speciale structuur van het traliediagram van de code. Het voordeel van het Viterbi decodeeralgoritme, in vergelijking met de optimale rekenintensieve methode, is dat de complexiteit van het Viterbi algoritme niet afh angt van de lengte L van de informatiesequentie. Het algoritme berekent een metriek of een afstand tussen de ontvangen sequentie op het tijdstip tz en alle mogelijke paden die toekomen in elke toestand in het traliediagram op tijdstip t; . Het Viterbi algoritme verwijdert d an alle paden die niet in aanmerking komen voor het optimale pad. Wanneer twee paden toekomen in eenzelfde toest and op het tijdstip tt wordt het pad met de beste metriek gekozen; dit pad wordt het overlevende pad genoemd. Immers, vanaf het knooppunt waar beide paden samenkomen, zal de performantie van het pad met de slechtste metriek nooit beter zijn dan de performantie v an de tak met de beste metriek, ongeacht welke bits daarna ontv angen worden. Deze selectie v an 192

informatiesequentie b

0

0

0

0

0

codesequentie c

00

00

00

00

00

ontvangen sequentie r

10

00

10

00

00

toestand a=00

b=10 . takmetriek c=01 .

d=11 . Figuur 7.13: Traliediagram voor de decoder

(R, = 1/2, K = 3)

overlevende paden wordt uitgevoerd voor alle toestanden. De decoder gaat op deze manier het volledige traliediagram doorlopen, en op elk tijdstip de minst waarschijnlijke paden elimineren. Door deze snelle eliminatie van de paden met lage waarschijnlijkheid is de complexiteit van het decodeeralgoritme laag. Men kan aantonen dat dit decodeeralgoritme asymptotisch optimaal is, en dat het algoritme equivalent is met vinden v an het codewoord met de minimale afstandsmetriek. We veronderstellen dat de codesequentie verstuurd wordt over een binair symmetrisch kanaal (harde decodering). In dat geval is de Hammingafstand een geschikte metriek om de paden te vergelijken. Als voorbeeld beschouwen we de encoder uit figuur 7.2, waarvan het traliediagram wordt getoond in figuur 7.4. Dit traliediagram en de uitgangen v an dencorvlktazijegndco,atezprigkndjae encoder en de decoder. Men gebruikt voor de decoder een gelijkaardig traliediagram (zie figuur 7.13). We starten op tijdstip t 1 in de nultoestand 00 (het afsluiten v an een bericht aan de encoder met (K — 1)k nullen zorgt ervoor dat we de begintoestand van decoder kennen). In het algoritme berekent men op elk tijdstip de Hammingafstand tussen de ontvan gen sequentie en de uitgang v an de encoder corresponderend met de verschillende takken in het traliediagram. Het voorbeeld in figuur 7.13 toont de informatiesequentie b = 00000... (de nulsequentie), het corresponderende codewoord c = 0000000000... en de ontvangen sequentie r = 1000100000.... In figuur 7.13 is bij elke tak de afstand (=de takmetriek) tussen de ontvangen sequentie en de uitgang van de encoder corresponderend met die tak aangegeven. Om de minst waarschijnlijke paden te kunnen elimineren definiëren we de cumulatieve metriek (=de padmetriek) van een pad op een gegeven tijdstip ti als de som van de Hammingafstanden van de takken v an dit pad tot het tijdstip t ti . Indien in een bepaald knooppunt

193

meerdere paden samenkomen, dan kiest het Viterbi decodeeralgoritme het pad met de kleinste cumulatieve metriek, en elimineert het algoritme alle andere paden die toekomen in dat knooppunt. Dit is mogelijk wegens de Markov natuur van de encoder: de volgende toestand van de encoder hangt enkel van de huidige toestand van de encoder en de huidige ingang van de encoder, maar niet meer van de vorige toest an den van de encoder. In figuur 7.14 worden een aantal traliestructuren getoond die het decoderen van de sequentie r met behulp van het Viterbi-algoritme illustreren. Het foutpatroon uit figuur 7.13 bevat twee fouten. Op tijdstip 2 is slechts één van de twee fouten opgetreden. De overlevende paden en de respectievelijke padmetrieken worden getoond in figuur 7.14(a). Na drie tijdstippen zal elk pad in figuur 7.14(a) zich in twee richtingen verder zetten, zodat er acht paden zijn. In elke toestand komen nu twee paden aan. De padmetrieken van de twee paden die aankomen in een toestand worden vergeleken, en enkel het beste pad wordt behouden, zodat steeds vier overlevende paden worden behouden. De overlevende paden worden getoond in figuur 7.14(b). Dit proces wordt verdergezet voor de volgende tijdstippen. Merk op dat na 5 tijdstippen (getoond in figuur 7.14(c)) het pad met allemaal nullen een kleinere padmetriek heeft dan de andere paden. Aangezien geen andere fouten zullen optreden, is het duidelijk dat na verloop van tijd uiteindelijk het juiste pad zal gekozen worden. Uit dit voorbeeld is het ook duidelijk dat de overlevende paden over een groot tijdsinterval kunnen verschillen. Echter, na 10 tijdstippen (figuur 7.14(e)) zien we dat de overlevende paden samenkomen, en dat de overlevende paden samenvallen gedurende de eerste 8 tijdstippen. Het Viterbi-algoritme kan op deze manier een beslissing nemen over de verstuurde symbolen: alle overlevende paden leiden naar hetzelfde knooppunt, dus naar hetzelfde informatiesymbool. Merk op dat het overlevende pad samenvalt met het werkelijke pad: de twee fouten kunnen gecorrigeerd worden. De diepte (het tijdsinterval) waarna de verschillende overlevende paden samenkomen, is een toevalsgrootheid en hangt af v an de ernst van het foutpatroon. Daarom k an de diepte niet algemeen bepaald worden. In de praktijk zal men niet vertrouwen op dit mechanisme en zal men pas een beslissing nemen na een vaste diepte. Deze diepte is in de praktijk meestal een veelvoud van de lengte van het geheugen v an de code K. We versturen opnieuw de nulsequentie. Beschouwen we nu een foutpatroon dat niet gecorrigeerd kan worden, bijvoorbeeld 11010000.... Een aantal traliestructuren die het decoderen weergeven voor deze sequentie zijn getoond in figuur 7.15. Merk op dat op tijdstip 3 het correcte pad geëlimineerd is, zodat er zeker een fout zal optreden. Verder zien we dat alle paden reeds samenvallen voor de eerste tak. Na 5 tijdstippen komen de overlevende paden reeds samen voor de eerste twee takken, en op tijdstip 11 zijn de eerste 9 takken gemeenschappelijk voor alle overlevende paden. Merk op dat ond an ks er een fout is opgetreden, het foutieve pad slechts afwijkt van het correcte pad over een relatief korte tijdsspanne (enkel drie takken). De informatiesequentie die met dit pad overeenkomt is 100000..., zodat slechts één enkele bitfout gemaakt is in de informatiesequentie. Dit voorbeeld demonstreert een karakteristieke eigenschap van de Viterbi-decoder: foutpatronen treden op gedurende een relatief korte tijdsspanne (typisch korter d an enkele keren de 194

(a) r=

00

10

(b) r=

10

00

2

2

2

1

(e) r=

10

2

1

1

00

10

00

10

(d) r=

10

2

00

2

00

00

00

00

2

2

2

00

00

00

00

00

00

2

10

00

2

00

2

00

Figuur 7.14: Het Viterbi algoritme: harde decodering, corrigeerbaar foutpatroon

195

•

(c) r=

11

01

00

00

00

00

00

00

00

00

00

00

Figuur 7.15: Het Viterbi algoritme: harde decodering, niet-corrigeerbaar foutpatroon geheugenlengte van de code) en resulteren in een korte burst van fouten. Merk op dat de code in het voorbeeld een minimale vrije afstand dfree = 5 heeft (zie vorige sectie). Aangezien het aantal fouten dat een binaire code kan corrigeren gelijk is aan L(dfree —1)/2J, kan de code uit het voorbeeld alle foutpatronen met twee fouten corrigeren. In het bovenstaande voorbeeld hebben we harde decodering gebruikt, waarbij de ontvangen sequentie bestaat uit bits. Het Viterbi-decodeeralgoritme is echter zeer eenvoudig uit te breiden naar zachte decodering. In het geval van zachte decodering modelleren we het kan aal als een geheugenloos k an aal met discrete ing an g en continue uitgang. De ing an g van het kanaal bestaat uit de binaire codesequentie x = (x0, x 1 , x2, ...), waarbij x ; de waarden { —1; +1} kan a an nemen: xi

= {+1 als —1 als

ci

=1 0

waarbij c = (co , c1 c2 , ...) de codesequentie voorstelt. Het kanaal voegt witte Gaussiaanse ruis w = (wo , w1 , w2, ...) toe met gemiddelde nul envariantiee N 0/2, ,

P( w i)

= ^

1 rNoe

No

,

zodat aan de ontvanger de sequentie y = (y o , y1 , y2 , ...) = x + w wordt ontvangen. Het grote verschil tussen harde en zachte Viterbi decodering is dat het zachte algoritme niet de Hammingafstand kan gebruiken als metriek. De metriek die bij zachte decodering wordt 196

ti toestand a=00

t2 -

t3 -1; 1

1; 1 -

t5

t4 -1;- 1

-1;1

t6 -1;- 1

b=10 .

c=01 .

d=11 .

ingangsbit 0 ingangsbit 1 Figuur 7.16: Traliediagram voor zachte transmissie gebruikt is de Euclidische afstand. Zachte Viterbi decodering verloopt op dezelfde wijze als harde decodering, behalve dat de tak- en padmetrieken de Euclidische afstand is tussen de ontvangen sequentie en de sequenties corresponderend met de verschillende takken en paden. Ook bij zachte decodering worden op elk tijdstip de paden geëlimineerd met de minste waarschijnlijkheid, d.w.z. met de kleinste padmetriek. In figuur 7.16 wordt het traliediagram weergegeven voor zachte transmissie. Bij elke tak wordt aangegeven welke binaire sequentie wordt verstuurd als de encoder zich in een gegeven toestand bevindt en in een andere toestand bel an dt door het toevoegen van een informatiebit. Merk op dat dit traliediagram zeer gelijkaardig is aan het traliediagram in figuur 7.4, waarbij de uitgangsbits E {0,1} corresponderend met elke tak zijn vervangen door de binaire sequentie E {+1; —1} die wordt verstuurd over het kanaal. Als voorbeeld van zachte Viterbi decodering beschouwen we de transmissie van de de nulsequentie b = (00000000000...). De sequentie die verstuurd wordt bestaat uit een sequentie met '—l'-en: x = (-1, —1, —1, —1, —1, —1, ...). Aan de ontvanger bekomen we de sequentie y = (0.1, 0.3, —1.7,0.2, —0.7, —0.3, —1.2, —0.9, —1.7, —0.8, —0.9, —1.8, —1.1, —2.2, —0.4, —1.3, —1.3, —2.1, —0.7, —0.4, —1.1, —1.5, ...). Indien we op deze sequentie harde decodering zouden toepassen, ri

=

1

als ya >0

0 als ya < 0

dan bekomen we de sequentie r = (11010000000...). In figuur 7.15 werd deze sequentie gedecodeerd met harde decodering. Deze sequentie kon niet correct gedecodeerd worden,

197

informatiesequentie b

0

0

0

0

0

verstuurde sequentie x

-1;-1

-1;-1

-1;-1

-1 ;-1

-1;-1

ontvangen sequentie y

0.1;0.3

-1.7;0.2

-0.7;-0.3

-1.2;-0.9

-1.7;-0.8

toestand a=00

b=10 .

takmetriek c=01 .

d=11 .

1.78

Figuur 7.17: Traliediagram voor zachte decodering, met takmetrieken en heeft tot gevolg dat één informatiebit foutief zal gedecodeerd worden. Decoderen we de sequentie y met zachte decodering, dan bekomen we de takmetrieken in het traliediagram in figuur 7.17. Bijvoorbeeld, voor de tak die op tijdstip t 1 vanuit toestand a naar toestand a gaat op tijdstip t2 is de takmetriek gegeven door de Euclidische afstand tussen de ontvangen sequentie (0.1; 0.3) en de sequentie (-1; —1) corresponderend met deze tak (zie figuur 7.16): (0.1 — (-1)) 2 + (0.3 — (-1)) 2 = 2.9. Analoog, voor de tak die op tijdstip t 1 vanuit toestand a naar toestand b gaat op tijdstip t 2 is de takmetriek (0.1 — 1) 2 + (0.3 — 1) 2 = 1.3. Net zoals bij harde decodering wordt bij zachte decodering de cumulatieve takmetriek - of de padmetriek - gebruikt om paden in de traliestructuur te elimineren. In figuur 7.18 worden de padmetrieken getoond op verschillende tijdstippen. Van de paden die op hetzelfde tijdstip aankomen in dezelfde toestanden worden de padmetrieken vergeleken. Enkel het pad met de beste padmetriek (met de laagste cumulatieve takmetriek) wordt behouden, zoals bij harde decodering. Merk op dat na 11 tijdstippen de overlevende paden samenvallen voor de eerste 9 tijdstippen, en dat het pad corresponderend met de nulsequentie de kleinste padmetriek heeft. Hieruit volgt dat het Viterbi algoritme met zachte decodering wel in staat is de sequentie correct te decoderen, terwijl bij harde decodering een decodeerfout wordt gemaakt. Dit betekent dat, net zoals bij blokcodes, een zachte decoder meer fouten kan corrigeren dan een harde decoder, zodat de performantie van een zachte decoder steeds beter zal zijn dan de performantie van een harde decoder.

198

2.9

2.9

4.83

4.83

5.41 2.52

10.83

12.61 1.94 0.52

10.52

12.3

• (a) y= 0.1;0.3

-

(b) y= 0.1;0.3 -1.7;0.2 -0.7:0.3

1.7;0.2

2.9

4.83

1.3

5.41

5.46

5.99

2.52

6.7

•/

•

14.7

1.94 7.3 (c) y= 2.9

0.1;0.3 -1.7;0.2 -0.7;0.3 -1.2;0.9 -1.7;-0.8 4.83

5.41

5.46

5.99

6.64

8.09

9.84

8.54

16 \l5.34

22.95 24.55 21.84

(d) y=

0.I;0.3 -1.7;0.2 -0.7;-0.3 -I.2;-0.9-1.7; 0.8 -0.9;-I.8 -1.1:-2.2 -0.4;-l.3-I.3;-2.1 2.9

4.83

5.41

5.46

5.99

6.64

8.09

8.54

9.84

10.29

10.55 20.95

\ N..20.95 19.35 (e) y•

0.1;0.3 -1.7;0.2 -0.7;0.3 -1.2;0.9 -1.7;0.8 -0.9;1.8 -1.1;2.2 -0.4;1.3 -1.3;-2 1 -0.7; 0.4 -1.1;-1.5

Figuur 7.18: Het Viterbi algoritme: zachte decodering, corrigeerbaar foutpatroon

199

7.6

Grenzen op de performantie van convolutionele codes

In deze sectie gaan we de foutprobabiliteit bepalen van het Viterbi algoritme, voor zowel harde als zachte decodering. Voor het geval van het Viterbi algoritme met zachte decodering beschouwen we de foutprobabiliteit w anneer het kana al gemodelleerd wordt als een additief wit Gaussiaans kanaal met zachte decodering, terwijl bij het Viterbi algoritme met harde decodering het kanaal gemodelleerd wordt als een binair symmetrisch kanaal.

7.6.1 Zachte decodering Bij het a fl eiden v an de foutprobabiliteit voor convolutionele codes maken we gebruik van de lineariteit om de uitdrukkingen voor de foutprobabiliteit te vereenvoudigen, m.a.w. we veronderstellen dat de nulsequentie verstuurd wordt, en we berekenen de foutprobabiliteit dat een andere sequentie wordt gekozen door de decoder. We definiëren {C j,m | m = 1, 2, ... , n} als de uitgang van de encoder voor de jde tak van de convolutionele code, waarbij n het aantal uitgangsbits van de decoder voorstelt tijdens een klokcyclus. Er wordt verondersteld dat de bits worden afgebeeld op een binaire sequentie {X j,,,,|m = 1, 2, ... , n}, waarbij = —1 alscj,m =0 • x3 'm +1 als cj,m = 1 De ingang van de Viterbi decoder bestaat uit de sequentie {r j,mdm = 1, 2, ... , n; j = 1, 2 ...}, gedefinieerd al s (7.19)

. m = /Eb,c (2Cj,m — 1) +Wj, m ,

waarbij wj,m de additieve witte ruis met gemiddelde nul en variantie N 0 /2 voorstelt, en Eb,c de energie verstuurd per codebit is. Het zachte Viterbi algoritme berekent de takmetrieken /di)

n (i)

=

(7.20)

2 Tjm (2Cjm — 1).

m=1 Hiermee berekent de decoder de padmetrieken B

CM(i)

B

µ

= j=1

n

^y) = E E Tj m(2C^'m ,

j =1

m=1

1),

(7.21)

waarbij i één van de concurrerende paden voorstelt op elk knooppunt, en B het aant al

200

takken

is in het pad. Bijvoorbeeld, het nulpad, met index i = 0, heeft de padmetriek: B

n

= E E(—vEb,c + wj,m)(-1) j= 1 m=1

B

n

— E j=1

= E;;Bn E

W j,m •

m=1

Aangezien de convolutionele code niet noodzakelijk een vaste lengte heeft, berekenen we de foutprobabiliteit voor de sequenties die voor het eerst samenvallen met het nulpad op een gegeven knooppunt in het traliediagram. In het bijzonder definiëren we de firstevent foutprobabiliteit als de probabiliteit dat een ander pad samenvalt met het nulpad in knooppunt B en dat de padmetriek van het nulpad voor de eerste keer kleiner is dan de padmetriek van het niet-nulpad. Stel dat het foutieve pad, we noemen dit pad i = 1, dat voor de eerste keer samenkomt met het nulpad verschilt van het nulpad in d bits, m.a.w. er zijn d '1'en in het pad i = 1, en alle andere bits zijn nul. De foutprobabiliteit in de paarsgewijze vergelijking van de metrieken CM(°> en CM( 1) is:

P2 (d) = P[CM (1) > CM (°>J = P[CM (1) — C/10> > OJ B n 2 = P E E rj,m(Cj lm — Cj °m) _> 0 .

(7.22)

j=1 m=1

Aangezien de gecodeerde bits in de twee paden gelijk zijn behalve in d posities, kan (7.22) geschreven worden als: d

P2(d) = P

rit > o) , E P=1

( 7.23)

waarbij de index 2 gaat over de set van d bits waarin de twee paden verschillen, en de set {r'P } de ingang v an de encoder voorstelt voor deze d bits. De waarden {r'p} zijn statistisch onafhankelijke Gaussiaanse toevalsgrootheden met gemiddelde — /Eb,c en variantie N0 /2. Hieruit volgt dat de foutprobabiliteit voor de paarsgewijze vergelijking van deze twee paden die van elkaar verschillen in d bits gegeven is door:

P2 (d) = Q(v 2Eb,c d YY No

Q(V2 waarbij Eb

d No ),

de energie verstuurd per informatiebit is, en

is. 201

R, = 1/n

(7.24) het debiet van de code

Hoewel we de first-event foutprobabiliteit - of de kans dat een decodeerfout optreedt hebben afgeleid voor een pad met afstand d van het nulpad, bestaan er veel paden met verschillende afstanden die samenkomen met het nulpad in het knooppunt B. Een volledige beschrijving van alle mogelijke paden die samenkomen met het nulpad in knooppunt B en hun respectievelijke afstanden kan worden bekomen uit de transfertfunctie T(D) van de code. We kunnen dus de foutprobabiliteit (7.24) sommeren over alle mogelijke afstanden. Door deze sommatie uit te voeren, bekomen we een bovengrens voor de first-event foutprobabiliteit van de vorm: 00

Pe <_

E

adP2(d)

d=diree

<

E

adQ

d=dJree

(

\/2RCd.Z. o

(7.25) )

waarbij ad het aantal paden voorstelt op afstand d van het nulpad dat voor de eerste keer samenvalt met het nulpad. Er zijn twee redenen waarom (7.25) een bovengrens vormt voor de first-event foutprobabiliteit. Een eerste reden is dat de gebeurtenissen die resulteren in de foutprobabiliteiten P2 (d) niet onafhankelijk zijn van elkaar. Dit kan afgeleid worden uit de traliestructuur. Ten tweede, door te sommeren over alle mogelijke d > dfree hebben we impliciet verondersteld dat de convolutionele code een oneindige lengte heeft. Indien de code periodisch afgebroken wordt na B knooppunten, kan de bovengrens in (7.25) verbeterd worden door te sommeren over de foutgebeurtenissen waarvoor d f1ee < d < B. Deze verfijning is van bel an g bij het bepalen van de performantie van korte convolutionele codes, maar het effect van deze afbreking op de performantie is klein wanneer B groot is. De bovengrens in (7.25) kan op een andere manier geschreven worden wanneer de Qfunctie naar boven wordt begrensd door een exponentiële, m.a.w. Q (

J4

< e - Red ó = Dd )

D=e— R

(7.26) '

Indien we (7.26) gebruiken in (7.25), d an kan de bovengrens op de first-event foutprobabiliteit worden geschreven als (7.27) Pe < T(D) D-e R e "

.

Hoewel convolutionelefoutprobabiliteit een maat is voor de performantie van de convolutionele code, is de bitfoutprobabiliteit een meer bruikbare maat voor de performantie. Deze bitfoutprobabiliteit kan naar boven begrensd worden gebruik makend van de procedure voor het begrenzen van de first-event foutprobabiliteit. Meer specifiek, indien we weten welk foutief pad wordt geselecteerd, dan zal de informatiebit waarvoor het gekozen pad afwijkt van het correcte pad, foutief zijn. We weten dat de exponenten in de factor

202

N in de transfertfunctie T(D, N) aangeven hoeveel informatiebits foutief (aantal keer '1') zijn indien men een foutief pad kiest dat voor de eerste keer samenkomt met het nulpad in knooppunt B. Indien we de paarsgewijze foutprobabiliteit P2 (d) vermenigvuldigen met het aantal incorrect gedecodeerde informatiebits voor het foutieve pad en het respectievelijke knooppunt, dan bekomen we de bitfoutprobabiliteit voor dat pad. De gemiddelde bitfoutprobabiliteit wordt naar boven begrensd door de paarsgewijze foutprobabiliteit P2(d) te vermenigvuldigen met het corresponderende aantal foutieve informatiebits, voor elk mogelijk foutief pad dat samenkomt met het correcte pad in het Bde knooppunt, en dan te sommeren over d. Het aantal foutieve informatiebits voor elk foutief pad kan bekomen worden door de transfertfunctie T(D, N) af te leiden naar N. In het algemeen kan T(D, N) geschreven worden als (7.28) adDdNf (d) , T(D, N) = 00

E

d=d free

waarbij f (d) de exponent van N voorstelt als functie van d. Nemen we de afgeleide van T(D, N) naar N, dan bekomen we OT(D, N) 8N

0

- E

adDdf (d)

(7.29)

QdDd,

(7.30)

d=d free

N=1

00

- E

d=d free

waarbij Qd = ad f (d). Hieruit volgt dat de bitfoutprobabiliteit voor k = 1 naar boven begrensd is door 00

Pb

<

ÏldP2(d) d=d free

< E d=d

QdQ ( 1 /2RcdN ) VV

free

(7.31)

o

Indien de Q-functie naar boven wordt begrensd door een exponentiële, zoals in (7.26), dan kan (7.31) geschreven worden als 00

Pb <

Ê

QdDd

d=d fre e

D =e - R

`

OT (D, N) <

ON

E

(7.32)

N=1,D=e -R `

Indien k > 1 dan kunnen de vergelijkingen voor de bitfoutprobabiliteit bekomen worden door (7.31) en (7.32) te delen door k. 203

7.6.2 Harde decodering We beschouwen in deze sectie de performantie die men kan bekomen met het Viterbi algoritme wanneer het kanaal wordt gemodelleerd als een binair symmetrisch kanaal. Bij harde decodering van convolutionele codes wordt de Hammingafstand tussen de ontvangen sequentie en de 2k(K-1) overlevende sequenties in elk knooppunt van het traliediagram gebruikt als metriek. Zoals in de afleiding van de performantie bij zachte decodering, beginnen we met het bepalen van de first-event foutprobabiliteit. Opnieuw veronderstellen we dat de nulsequentie wordt verstuurd. Stel dat het pad dat vergeleken wordt met het nulpad in een knooppunt B een afstand d heeft tot het nulpad. Indien d oneven is, dan zal het nulpad worden gekozen indien het aantal fouten in de ontvangen sequentie kleiner is dan (d+ 1)/2; anders zal het foutieve pad worden geselecteerd. Hieruit volgt dat de kans dat het foutieve pad wordt geselecteerd gelijk is aan d

(1

P2(d)= k=(d+1)/2

waarbij

p

(7.33)

- p )d-k ,

(d)

de kans op een bitfout is in het binair symmetrisch kanaal. Indien d even is, dan wordthefuivpagslctrdwnehalfoutidnvgesqt

groter is dan d/ 2. Indien het aantal fouten gelijk is a an d/ 2, dan zijn de metrieken van beide paden gelijk: beide paden zijn even waarschijnlijk. In dat geval kiest men willekeurig één van de twee paden, zodat slechts de helft van de tijd een fout optreedt. Hieruit volgt dat de kans dat het foutieve pad wordt geselecteerd gelijk is aan d (d

P2(d) _

1

) k (l

(d 2J pd21

k=d/2+1

—

(7.34)

Zoals bij zachte decodering bestaan er veel paden met verschillende afst anden van het nulpad die samenkomen met het nulpad in een gegeven knooppunt. Daarom bestaat er geen eenvoudige exacte uitdrukking voor de first-event foutprobabiliteit. Echter, het is mogelijk een bovengrens voor deze foutprobabiliteit te bepalen door de som van de paarsgewijze foutprobabiliteiten P2 (d) te sommeren over alle mogelijke paden die samenkomen met het nulpad in een gegeven knooppunt. We bekomen dan de bovengrens: 00

Pe <

E

adP2(d),

(7.35)

d=d)ree

waarbij de coëfficiënten {a d } het aantal paden corresponderend met de afstanden {d} aangeven. Deze coëfficiënten zijn de coëfficiënten in de exp ansie van de transfertfunctie T(D) of T(D, N). In plaats van de uitdrukkingen (7.33) en (7.34) te gebruiken, kunnen we de Chernov bovengrens gebruiken voor de foutprobabiliteit Pc . 204

Chernov bovengrens: Voor een toevalsgrootheid X geldt dat P[X > y]

<e

-

73E[esx]

=

eµ(s) - 73,

(7.36)

waarbij µ(s) = 1n M(s) en M(s) = E[es]] de momentengenererende functie is van X. De parameter s wordt zo gekozen dat de bovengrens minimaal wordt. We passen de Chernov bovengrens toe op de paarsgewijze foutprobabiliteit P2 (d). Deze foutprobabiliteit, die overeenstemt met de kans dat een foutief pad op afstand d van het nulpad wordt geselecteerd en niet het nulpad, is gelijk aan de de kans dat tenminste d/2 bits foutief worden ontvangen, dus als de bits gelijk zijn aan '1': d

P2(d)= P Er;> 2-d )

Vd,

(7.37)

4=1

waarbij {rq } de ontvangen bitsequentie voorstelt. Met de Chernov bovengrens kunnen we (7.37) begrenzen door P2(d) < e-d8/2E [es EL lr. (7.38) ]

De bits ri zijn statistisch onafhankelijk en hebben dezelfde statistiek zodat P2(d) < e-d312 (E [esr])d

(7.39)

De coëfficiënt s wordt zo gekozen dat de bovengrens minimaal is. Leiden we de bovengrens af naar s, dan bekomen we dat s moet voldoen aan (7.40) E[rers] = 2E[ers]. Voor een binair symmetrisch kanaal met foutprobabiliteit p geldt (uitgaande van het feit dat de nulsequentie werd verstuurd, geldt dat P(r = 1) = pen P(r = 0) = 1 - p): E[ers ] = pes + (1 - p) E[rers] = pes .

Hieruit volgt dat de optimale waarde van s gegeven is door sopt= ln

1 ; p. p

(7.41)

Substitueren we (7.41) in (7.39), dan bekomen we de bovengrens P2(d) < [4p( 1 — p)] d^2•

(7.42)

Met deze bovengrens voor de paarsgewijze foutprobabiliteit kunnen we een bovengrens voor de first-event foutprobabiliteit bekomen: 00 Pe < ad[4p( 1 - p)]d/2

>

d=d j

<

,.

(D)I D= v 4p(1-p)

205

(7.43)

We bepalen nu de bitfoutprobabiliteit voor de convolutionele code. Zoals bij zachte decodering maken we gebruik van het feit dat de exponenten van N in T(D, N) aangeven wat het gewicht is van de foutieve informatiebits wanneer een foutief pad wordt gekozen in plaats van het nulpad. Door het afleiden van T(D, N) naar N en N = 1 te nemen, worden de exponenten van N de vermenigvuldigingsfactoren voor de corresponderende foutprobabiliteiten P2(d). Op deze manier bekomen we een bovengrens voor de bitfoutprobabiliteit van de vorm Pb <

Ê

k d=dl ,.ee

1-10-2(1))

(7.44)

waarbij {,Qd } de coëfficiënten zijn in de expansie van de afgeleide van T(D, N), geëvalueerd voor N = 1. Voor P2(d) kunnen we de uitdrukkingen (7.33) of (7.34) gebruiken, of de bovengrens (7.42). Indien deze bovengrens wordt gebruikt kan de bitfoutprobabiliteit worden geschreven als 1 OT(D, N) Pb< k ON

(7.45) N=1,D=,4p(1-p)

7.6.3 Vergelijking tussen harde en zachte decodering Een vergelijking van de bitfoutprobabiliteit bij harde en zachte decodering voor de convolutionele code met R = 1/2, K = 2 uit figuur 7.2 wordt getoond in figuur 7.19. De bovengrens voor harde decodering (7.44) in combinatie met (7.33) en (7.34) is strenger dan de Chernov bovengrens (7.45). Merk echter op dat het verschil kleiner is dan 1 dB. Het voordeel van de Chernov bovengrens is de lagere rekencomplexiteit. Vergelijken we de bitfoutprobabiliteit van zachte en harde decodering, d an bekomen we een verschil in codewinst v an ongeveer 2 dB voor 10 -2 > Pb > 10-6 .

7.7 Puncturing In bepaalde praktische toepassingen zijn er convolutionele codes met hoog debiet, vb. (n — 1)/n, nodig. In het traliediagram voor convolutionele codes met dit debiet komen in elk knooppunt 2n-1 takken toe. Hieruit volgt dat per toestand 2n-1 padmetrieken moeten berekend worden in het Viterbi algoritme, en evenveel vergelijkingen moeten uitgevoerd worden tussen de padmetrieken om het overlevende pad te berekenen. Daarom is de implementatiecomplexiteit van een code met een hoog debiet hoog. De hoge implementatiecomplexiteit van een convolutionele code met hoog debiet kan vermeden worden door een code met hoog debiet af te leiden uit een code met laag debiet, waarbij een aantal van de gecodeerde bits worden weggelaten. Het weglaten van codebits aan de uitg an g van een convolutionele encoder noemt men puncturing. Op deze manier kan men codes met hoog debiet genereren, door puncturing v an codes met debiet 1/n, met 206

1.E+00

bitfoutprobabiliteit Pb

1.E-01

1.E-02

1.E-03

1.E-04 zachte decodering

1.E-05

— — — harde decodering — • -- Chemov bovengrens harde decodering

1.E-06 0

2

4

6 Eb/No dB (

8

)

Figuur 7.19: Verge lijking tussen harde en zachte decodering voor de convolutionele code

207

10

K=

3,

k=

1, n = 2

als resultaat dat de decoder slechts de implementatiecomplexiteit heeft van de code met debiet 1/n. Merk wel op dat puncturing de minimale vrije afstand van de 1/n code doet afnemen. De afname van de minimale vrije afstand hangt af van de graad van puncturing. De 1/n convolutionele code waarmee de code met hoog debiet wordt gegenereerd noemt men de moedercode. Het puncturingproces kan beschreven worden als een periodisch weglaten van bits aan de uitgang van de encoder, waarbij dus een traliediagram wordt gecreeërd dat op een periodische manier afhangt van de tijd. We beginnen met een 1/n convolutionele code en we definiëren de puncturingperiode P, corresponderend met P informatiesymbolen aan de ingang van de encoder. Dit betekent dat in één periode er nP gecodeerde bits zijn. Bij deze nP gecodeerde bits hoort een puncturingmatrix P van de vorm P21

P12 P22

Pni

Pn2

p11

P

=

' ' •

PIP

' ' '

P2P

" •

PnP

(7.46)

waarbij elke kolom van P correspondeert met de n mogelijke uitgangsbits voor elk ingangsbit, en elk element van P is 0 of 1. Wanneer pij = 1, dan wordt de corresponderende uitgang van de encoder verstuurd; wanneer pik = 0 dan wordt de corresponderende uitg ang van de encoder weggelaten. Hieruit volgt dat het debiet van de code wordt bepaald door de periode P en het aantal weggelaten bits. Indien we N bits van de nP gecodeerde bits weglaten, dan is het debiet v an de code gelijk aan PI (nP — N), waarbij N alle gehele waarden tussen 0 en (n —1)P kan aannemen. Hieruit volgt dat de mogelijke debieten gegeven zijn door R

P

P + M'

M = 1,2,...,(n — 1)P

(7.47)

Voorbeeld: We construeren een R e = 3/4 code door puncturing toe te passen op de Re = 1/2 code uit figuur 7.2. Er bestaan verschillende waarden van P en M om het gewenste debiet te bekomen. De kleinste waarde van P waarmee we het gewenste debiet kunnen bereiken is P = 3. Dan worden uit elke nP = 6 codebits N = 2 bits weggelaten. Hiermee bekomen we een code met debiet R, = 3/4. Een mogelijke puncturingmatrix P is gegeven door

P=i1

l j•

(7.48)

Figuur 7.20 toont de generatie van het traliediagram voor de Re = 3/4 code uit de Re = 1/2 moedercode. Het traliediagram voor de R e = 3/4 code wordt ook getoond in figuur 7.20. 208

...1001 punctured 1 bits

informatiebits ...1i01

puncturing matrix

(a) ti toestand a)0

t2 00 __

13

OX

t4

_ XO _

ts

00

16

OX

(b)

Figuur 7.20: Generatie van een R, = 3/4 code uit een Re Traliediagram

= 1/2 code (a) Encoder (b)

In het bovenstaande voorbeeld werd de puncturingmatrix willekeurig gekozen. Echter, sommige puncturingmatrices zijn beter dan andere in de zin dat de paden in het traliediagram op grotere Hammingafstand liggen. Er is veel rekenwerk nodig om goede puncturingmatrices te vinden (dit kan gedaan worden met de computer). In het algemeen geldt dat de convolutionele codes met hoog debiet die met puncturing worden gegenereerd een minimale vrije afstand hebben die gelijk is aan of 1 bit minder dan de minimale vrije afstand voor de beste convolutionele code met hoog debiet bekomen zonder puncturing. Het decoderen van punctured convolutionele codes gebeurt op dezelfde manier als het decoderen van de 1/n moedercode, door gebruik te maken van het traliediagram van de 1/n code. De padmetrieken worden berekend zoals beschreven in sectie 7.5. Wanneer een of meerdere bits in een tak weggelaten werden, dan wordt de takmetriek berekend met enkel de niet-weggelaten bits, m.a.w. de weggelaten bits hebben geen bijdrage tot de takmetriek. In het algemeen duurt het bij punctured codes langer dan bij de moedercode vooraleer de overlevende paden samenvallen. Hieruit volgt dat de decoder langer moet wachten vooraleer hij een beslissing kan nemen over de verstuurde bits. 209

Bij zachte decodering is de performantie van een punctured code gegeven door de uitdrukking (7.25) voor de first-event foutprobabiliteit (bovengrens). De bitfoutprobabiliteit (bovengrens) is gegeven door Pb < _

b d=djE,- /dQ cc

(

/2Rd

)

(7.49)

waarbij Rc = b/c het debiet is van de punctured code, en b het aantal informatiebits per tak is. Een man ier om goede punctured codes te ontwerpen is het zoeken naar puncturingmatrices waarvoor de minimale vrije afstand maximaal wordt. Een andere, betere benadering is het gewichtsspectrum {A} van de dominante termen van de punctured code te bepalen, en de corresponderende bovengrens (7.49) op bitfoutprobabiliteit te berekenen. De code corresponderend met de puncturing matrix met de beste foutperformantie kan worden gebruikt, op voorwaarde dat deze code niet catastrofaal is.

Bibliografie • Sergio Benedetto, Ezio Biglieri, "Principles of Digital Transmission: With Wireless Applications", Plenum, 1999 • Richard E. Blahut, "Theory and Practice of Error Control Codes", Addison-Wesley, 1983 • George C. Clark Jr., J. Bibb Cain, "Error-Correcting Coding for Digital Communications" , Plenum, 1982 • Thomas M. Cover, Joy A. Thomas, "Elements of Information Theory", Wiley, 1990 • Robert G. Gallager, "Information Theory and Reliable Communication", Wiley, 1968 • E.A. Lee, David G. Messerschmit, "Digital Communications", Kluwer Academic Publishers, 1988 • John G. Proakis, "Digital Communications", Mc Graw-Hill, 2001 • Man Young Rhee, "Error Correcting Coding Theory", Mc Graw-Hill, 1989 • Claude Elwood Shannon, A. D. Wyner, Neil J. A. Sloane, "Claude Elwood Shannon: Collected Papers", Wiley, 1993 • Bernard Sklar, "Digital Communications - Fundamentals and Applications", Prentice Hall, 2000

211