BCH-code (coderingstheorie)

Uit testwiki
Naar navigatie springen Naar zoeken springen

In de coderingstheorie is een BCH-code een cyclische foutcorrigerende code die gegenereerd wordt door een polynoom over een eindig lichaam. BCH-codes zijn in 1959 bedacht door Hocquenghem en onafhankelijk van deze in 1960 door Bose en Ray-Chaudhuri. De afkorting BCH is opgebouwd uit hun initialen.

Een groot voordeel van BCH-codes is dat ze worden gedecodeerd door middel van een algebraïsche methode die bekendstaat als syndroom decoderen. Hierdoor kan de benodigde elektronische hardware eenvoudig zijn, en is het energieverbruik beperkt. Daarnaast zijn ze als een klasse codes flexibel, met instelbaarheid van bloklengte en inzetbaarheid bij in de praktijk voorkomende bitfoutkansen. Dus bij een specificatie kan een code worden ontworpen (vanzelfsprekend wel binnen de wiskundige grenzen).

Technisch uitgedrukt is een BCH-code een multiniveau, cyclische, fout-corrigerende, variabele lengte digitale code, die gebruikt wordt voor het corrigeren van foutpatronen met meer dan één bitfout per blok. BCH-codes kunnen ook worden gebruikt met multiniveau phase-shift keying, mits het aantal niveaus een priemgetal is, of een macht van een priemgetal. Een BCH-code met 11 niveaus is gebruikt voor het representeren van 10 decimale digits plus een teken.

Constructie

Een BCH-code wordt gegenereerd door een polynoom over een eindig lichaam 𝔾𝔽(q), waarin q een macht van een priemgetal is.

Een eenvoudige klasse BCH-codes

Definitie

Voor positieve gehele getallen q,m,n, en d met q een priemgetal, n=qm1 en 2dn, wordt een polynoomcode met bloklengte n en een minimum hammingafstand van minstens d bepaald door de genererende polynoom die het kleinste gemeenschappelijke veelvoud g(x)=kgv(m1(x),,md1(x)) is. Daarin is mi(x) de minimale polynoom van αi over 𝔾𝔽(q), met α een primitief element in 𝔾𝔽(qm).

Voorbeeld

In het voorbeeld is q=2 en m=4, dus n=15.

Volgens de theorie bestaat er een primitieve wortel α𝔾𝔽(16) met een minimale polynoom van graad m die voldoet aan:

α4+α+1=0

De bijbehorende minimale polynoom over 𝔾𝔽(2) is:

m1(x)=x4+x+1

In 𝔾𝔽(2) geldt (a+b)2=a2+2ab+b2=a2+b2, zodat:

m1(α2)=α8+α2+1=(m1(α))2=0

Dus α2 is een wortel van m1(x), en blijkbaar is:

m2(x)=m1(x)=x4+x+1

De minimale polynoom m3(x) van α3 is ook van de graad 4:

Nu is:

α4+α+1=0,

dus

α4=α+1,

zodat

α6=α4α2=(α+1)α2=α3+α2
α9=(α4)2α=(α2+1)α=α3+α
α12=(α4)3=(α+1)3=(α2+1)(α+1)=α3+α2+α+1

Het blijkt dat

(α3)4+(α3)3+(α3)2+α3+1=α12+α9+α6+α3+1=
=α3+α2+α+1+α3+α+α3+α2+α3+1=0

De minimale polynoom van α3 is de polynoom

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

Op vergelijkbare wijze vindt men:

m4(x)=m2(x)=x4+x+1
m5(x)=x2+x+1
m6(x)=m3(x)=x4+x3+x2+x+1
m7(x)=x4+x3+1

Deze polynomen zijn juist de vier irreducibele polynomen.

De BCH-code met d=1,2,3 heeft als genererende polynoom

d(x)=m1(x)=x4+x+1

De minimale hammingafstand is minstens 3 en hij corrigeert 1 bitfout. Omdat de genererende polynoom van de graad 4 is, heeft deze code 11 data-bits en 4 checkbits.

De BCH-code met d=4,5 heeft als genererende polynoom

d(x)=kgv(m1(x),m3(x))=(x4+x+1)(1+x+x2+x3+x4)=x8+x7+x6+x4+1

De minimale hammingafstand is minstens 5 en de code corrigeert 2 bitfouten. Omdat het genererende polynoom de graad 8 heeft, bevat deze code 7 data-bits en 8 checkbits.

De BCH-code met d=6,7 heeft als genererende polynoom

d(x)=kgv(m1(x),m3(x),m5(x))=(x4+x+1)(1+x+x2+x3+x4)(x2+x+1)=x10+x8+x5+x4+x2+x+1

De minimale hammingafstand is minstens 7 en de code corrigeert 3 bitfouten. Deze code heeft 5 data-bits en 10 checkbits.

De BCH-code met d=8 en hoger heeft als genererende polynoom

d(x)=kgv(m1(x),m3(x),m5(x),m7(x))=(x4+x+1)(1+x+x2+x3+x4)(x2+x+1)(x4+x3+1)=x14+x13+x12++x2+x+1

Deze code heeft minstens hammingafstand 15 en corrigeert 7 bitfouten. De code heeft 1 data-bit en 14 checkbits. Feitelijk bestaat deze code uit de volgende twee codewoorden: 000000000000000 and 111111111111111.

Algemene BCH-codes

Algemene BCH-codes wijken op twee punten af van de hierboven behandelde eenvoudige BCH-codes. Ten eerste is de eis dat n=qm1 vervangen door een meer algemene eis. Ten tweede is het zo dat de opeenvolgende wortels van de generatorpolynoom niet bij α1 hoeven te beginnen; voldoende is dus als de rij eruitziet als volgt: αc,,αc+d2 (in plaats van α,,αd1).

Definitie

Neem een eindig lichaam 𝔾𝔽(q), waarbij q een macht is van een priemgetal. Kies positieve gehele getallen m,n,d,c zodat 2dn, ggd(n,q)=1, en m is de multiplicatieve orde van q modulo n (dat wil zeggen m is de kleinste macht met de eigenschap dat qm=1 modulo n).

Zoals hierboven is α een primitieve n-de machts eenheidswortel in 𝔾𝔽(qm), en is (voor alle i) mi(x) de minimale polynoom over 𝔾𝔽(q) van αi. De generatorpolynoom van de BCH-code is nu gedefinieerd als het kleinste gemeenschappelijke veelvoud g(x)=kgv(mc(x),,mc+d2(x)).

NB

Als n=qm1, zoals in het eenvoudige geval, is ggd(n,q) gelijk aan 1, en is de orde van qmodn automatisch gelijk aan m. De 'eenvoudige' BCH-code is dus inderdaad een specifiek voorbeeld binnen de algemene BCH-codes.

Eigenschappen

1. De generatorpolynoom van een BCH-code heeft als graad ten hoogste (d1)m. En als q=2 en c=1, dan is de graad van de generatorpolynoom ten hoogste dm/2.

Bewijs: elke minimale polynoom mi(x) heeft als graad ten hoogste m. Het kleinste gemeenschappelijke veelvoud van d1 minimale polynomen heeft dus ten hoogste de graad (d1)m. En als q=2, is mi(x)=m2i(x) voor alle i. Dus g(x) is het kleinste gemeenschappelijke veelvoud van ten hoogste d/2 minimale polynomen mi(x) voor oneven indices i, die elk ten hoogste de graad m hebben.

2. Een BCH-code heeft als minimale hammingafstand ten minste d. Bewijs in het eenvoudige geval (het bewijs voor het algemene geval is vergelijkbaar). Neem aan dat p(x) een codewoord is met minder dan d digits ongelijk aan nul. Dan is

p(x)=b1xj1++bd1xjd1, waarbij j1<j2<<jd1

We wisten dat α1,,αd1 wortels zijn van g(x), en dus ook van p(x). Hieruit volgt dat b1,,bd1 aan de volgende vergelijkingen voldoen voor i=1,,d1:

p(αi)=b1αij1+b2αij2++bd1αijd1=0

Dit delen we nu door αij1, en we definiëren kl=jlj1, om als resultaat te verkrijgen

b1+b2αik2++bd1αikd1=0

voor alle i, hetgeen equivalent is met

[1αk2αkd11α2k2α2kd11α(d1)k2α(d1)kd1][b1b2bd1]=[000]

Deze matrix is een vandermonde-matrix, en heeft als determinant

det(V)=1i<jd1(αkjαki),

hetgeen ongelijk aan nul is. Hieruit volgt dat b1,,bd1=0, en dus p(x)=0.

3. Een BCH-code is cyclisch.

Bewijs: een polynoomcode met bloklengte n is dan en slechts dan cyclisch als zijn generatorpolynoom een deler is van xn1. Omdat g(x) de minimale polynoom is met wortels αc,,αc+d2, behoeft slechts te worden gecontroleerd dat alle αc,,αc+d2 wortel zijn van xn1. Echter, dit volgt direct uit het feit dat α per definitie een nde machts eenheidswortel is.

Speciale gevallen

  • Een BCH-code met c=1 wordt een BCH-code in engere zin genoemd.
  • Een BCH-code met n=qm1 wordt primitief genoemd.

De hierboven beschouwde "eenvoudige" BCH-codes vormen precies de primitieve BCH-codes in engere zin.