Otra construcción de códigos array cíclicos, MDS y LDPC J.

XXI Congreso de Ecuaciones Diferenciales y Aplicaciones
XI Congreso de Matemática Aplicada
Ciudad Real, 21-25 septiembre 2009
(pp. 1–8)
Otra construcción de códigos array cíclicos, MDS y LDPC
J.-J. Climent y S. Díaz
Departament de Ciència de la Computació i Intel·ligència Artificial, Universitat d’Alacant,
Ap. correus 99, E-03080 Alacant. E-mails: [email protected], [email protected].
Palabras clave:
código array, código cíclico, código MDS, array de índices, logaritmo de Zech
Resumen
En este artículo presentamos un método para construir el array de índices de un
código array cíclico y LDPC. Esta construcción utiliza el logaritmo de Zech para
definir una partición de las columnas de la matriz de control del código. Dadas las
propiedades de este logaritmo, en algunos casos el código resultante es también un
código array MDS. Además, proporcionamos un algoritmo basado en el método de
Gauss, para comprobar si el código obtenido es MDS o no.
1
Introducción
Los códigos array son códigos correctores de errores y de borrones. Tienen aplicaciones
importantes en comunicación y sistemas de almacenamiento [3, 9, 10] y han sido ampliamente estudiados [1, 2, 4]. Una propiedad muy común de los códigos array es el hecho
de que los algoritmos de codificación y decodificación usan sólo operaciones XOR, así los
códigos array que son MDS son más eficientes en términos de complejidad computacional
que los códigos de Reed-Solomon [3]. Además, los códigos MDS ofrecen la máxima protección contra fallos de dispositivo dada una cantidad de redundancia. Se pueden ver algunas
construcciones de códigos array MDS en [1, 2, 5, 7, 9, 10]. En este artículo proporcionamos
una construcción para obtener códigos array cíclicos y algunas veces MDS.
El resto del artículo está organizado de la siguiente forma: En la sección 2 presentamos algunas definiciones básicas y la notacián utilizada. En la sección 3 introducimos la
construcción del array de índices de un código array, utilizando los logaritmos de Zech
para definir los elementos del array. Los códigos obtenidos son LDPC y cíclicos. Podemos
elegir cuantos unos queremos que contengan las columnas. Dependiendo de este número,
el código obtenido será algunas veces MDS.
1
J.-J. Climent y S. Díaz
2
Preliminares
Supongamos que Fq es el cuerpo de Galois de q elementos. Es bien conocido que Fbq ≈ Fqb .
Denotamos también por hni el conjunto {0, 1, 2, 3, . . . , n}. Dada una matriz de tamaño
m × n la numeración de las filas comienza en 0 y termina en m − 1 y la de las columnas
comienza en 0 y termina en n − 1.
Definición 1: Sea b un entero positivo. Dado un código C de longitud n sobre Fbq , podemos
considerar las palabras de C como palabras de Fnb
q . Decimos que C es un código array
b
lineal de longitud n sobre Fq si es un código lineal de longitud nb sobre Fq .
C
Si dim C es la dimensión de C como espacio vectorial sobre Fq , entonces k = dim
es la
b
dimensión normalizada de C, y así los parámetros del código serán [n, k, d], donde d es
la distancia mínima (medida sobre Fbq ).
Definición 2: Sea C un [n, k]-código array lineal sobre Fbq y H = [hi,j ] una matriz de
control de tamaño (n − k) × n sobre Fbq o, equivalentemente, de tamaño (nb − kb) × nb
sobre Fq . Llamamos array de índices AH al array asociado a la matriz H, de tamaño
b × n, que tiene en la posición (i, j) el conjunto {t | ht,i+bj = 1}, es decir, los índices de las
filas de H que tienen un 1 en la columna i + bj.
Cuando tenemos una matriz de control, o una generadora, de un código, éste está
unívocamente definido. Ocurre lo mismo con el array de índices, que nos indica en que
posiciones de la matriz de control, o de la generadora, están los elementos no nulos. Veamos
un ejemplo.
Ejemplo 1: Consideremos
control es

1 0 0
 0 0 1

 0 0 0
H=
 0 0 1

 0 1 0
0 1 0
el [18, 12]-código lineal C sobre F2 , una de cuyas matrices de
0
1
0
0
0
0
1
0
0
0
0
1
0
0
1
0
1
0
0
0
1
0
0
0
1
1
0
0
0
0
0
0
0
1
0
1
0
0
0
1
0
0
0
1
1
0
0
0
1
0
0
0
1
0
0
0
0
0
1
0
0
0
1
1
0
0
0
1
0
0
0
1
0
0
0
0
0
1
0
0
0
1
1
0
1
0
1
0
0
0




.



Podemos ver el código también como un [6, 4]-código sobre F32 . Por tanto, el array de
índices será de tamaño 3 × 6 y tendrá la siguiente forma:
0
1
2
3
4
5
AH = 4, 5 5, 0 0, 1 1, 2 2, 3 3, 4
1, 3 2, 4 3, 5 4, 0 5, 1 0, 2
En general, podemos realizar esta construcción para cualquier [n, k]-código lineal sobre
Fq no array, siendo b simplemente un divisor n. A partir de ahora hablaremos sólo de array
cuando queramos referirnos a array de índices.
A continuación, recordamos el concepto de logaritmo de Zech que utilizaremos para
nuestros resultados. Sea α un elemento primitivo de Fq , sabemos que
Fq = {0, 1, α, α2 , · · · , αq−2 }.
2
Otra construcción de códigos array cíclicos, MDS y LDPC
Esta representación de Fq es bastante útil a la hora de realizar el producto entre dos
elementos del cuerpo ya que:
αi αj = α(i+j) mod (q−1)
Sin embargo, no es tan sencillo para la suma de dos elementos del cuerpo. Ahora bien, si
i < j entonces
αi + αj = αi (1 + αj−i ).
Como 1 + αj−i ∈ Fq , tenemos que 1 + αj−i = αt para algún t. De aquí la necesidad de
introducir la siguiente definición.
Definición 3: Consideremos α un elemento primitivo del cuerpo Fq . Si x ∈ hq−2i, decimos
que Zα (x) ∈ hq − 2i ∪ {∞} es el logaritmo de Zech de x en la base α si
αx + 1 = αZα (x) ,
donde, por cuestiones de notación, suponemos que 0 = α∞ .
3
Resultados
En esta sección construimos un tipo de códigos array binarios, LDPC que también son
cíclicos y en algunos casos MDS, para lo cual construimos el array correspondiente a una
matriz de control H de dicho código.
En todo lo que sigue p será un número primo, n = p − 1 y supongamos que n = br,
con b y r números enteros mayores que 1. Nuestro código será de longitud n sobre Fb2 y
de dimensión normalizada k = n − r. Por lo tanto, la matriz de control H será de tamaño
(n − k) × n sobre Fb2 o, equivalentemente, de tamaño (nb − kb) × nb sobre F2 . Esta matriz
contendrá las n columnas de la matriz identidad y el resto de columnas contendrán r unos
cada una.
Supongamos también que α es un elemento primitivo de Fp y consideremos los subconjuntos de Zn
Ei = {i, i + b, i + 2b, . . . , i + (r − 1)b} con i ∈ hb − 1i.
Claramente, estos conjuntos constituyen una partición de Zn , es decir, de los exponentes
de los elementos de F?p expresados como potencias de α.
S
Consideremos la aplicación Φ : Zn −→ Z?n {∞} dada por Φ(x) = Zα (x), donde Zα (x)
es el logaritmo de Zech de x en la base α. Puesto que
n
α 2 + 1 = p − 2 + 1 = 0 = α∞
(véase [6]) tenemos que Φ( n2 ) = ∞. Además es fácil comprobar que n2 ∈ E n2 mod b , por lo
que eliminamos este conjunto y aplicamos Φ al resto.
Denotemos por Di = Φ(Ei ) para i = 0, 1, . . . , b − 1 pero i 6= n2 mod b. El array AH
3
J.-J. Climent y S. Díaz
tendrá la forma siguiente:
0
D0
D1
..
.
D p−1 −1
2
D p−1 +1
2
..
.
Db−1
···
···
···
1
2
D0 + 1
D0 + 2
D1 + 1
D1 + 2
..
..
.
.
D p−1 −1 + 1 D p−1 −1 + 2
2
2
D p−1 +1 + 1 D p−1 +1 + 2
2
2
..
..
.
.
Db−1 + 1
Db−1 + 2
···
···
···
p−3
p−2
D0 + p − 3
D0 + p − 2
D1 + p − 3
D1 + p − 2
..
..
.
.
D p−1 −1 + p − 3 D p−1 −1 + p − 2
2
2
D p−1 +1 + p − 3 D p−1 +1 + p − 2
2
2
..
..
.
.
Db−1 + p − 3
Db−1 + p − 2
(1)
A partir de este array podemos obtener la matriz H del código. Veamos un ejemplo.
Ejemplo 2: Tomemos p = 11, por lo tanto, n = 10. Sean r = 2 y b = 5. Entonces
E0 = {0, 5}, E1 = {1, 6}, E2 = {2, 7}, E3 = {3, 8} y E4 = {4, 9},
que claramente forman una partición de Z10 .
Calculamos la tabla de logaritmos de Zech para F11 tomando como elemento primitivo α = 2:
x
0
Zα (x) 1
1
8
2
4
3
6
4 5 6 7 8 9
9 ∞ 5 3 2 7
De acuerdo con lo dicho anteriormente eliminamos el conjunto E0 = {0, 5} y aplicando el
logaritmo de Zech al resto obtenemos
D1 = {5, 8}, D2 = {3, 4}, D3 = {2, 6} y D4 = {7, 9}.
Con estos conjuntos obtenemos la primera columna del array y, a partir de ella, el resto de
columnas tal como indicamos en la expresión (1). Por tanto, el array será:
0
5, 8
3, 4
2, 6
7, 9
1
6, 9
4, 5
3, 7
8, 0
2
7, 0
5, 6
4, 8
9, 1
3
8, 1
6, 7
5, 9
0, 2
4
9, 2
7, 8
6, 0
1, 3
5
0, 3
8, 9
7, 1
2, 4
6
1, 4
9, 0
8, 2
3, 5
7
2, 5
0, 1
9, 3
4, 6
8
3, 6
1, 2
0, 4
5, 7
9
4, 7
2, 3
1, 5
6, 8
El número de unos de una matriz que viene determinada por su array es el número de elementos
que hay en este array. Llamamos densidad del código a dicho número.
Por la forma que tiene el array de la construcción anterior, podemos establecer el siguiente
resultado, cuya prueba es inmediata.
Teorema 1: El número de unos de cada fila de la matriz de control H asociada a un array del
tipo (1) es n − r + 1.
3.1
Ciclicidad
En esta sección vamos a probar la ciclicidad de los códigos que se obtienen con la anterior construcción. Para ello, primero recordamos algunos resultados.
Definición 4: Decimos que un código C de longitud n sobre Fbq es cíclico si (c0 , c1 , . . . , cn−1 ) ∈ C
implica que (cn−1 , c0 , c1 , . . . , cn−2 ) ∈ C.
4
Otra construcción de códigos array cíclicos, MDS y LDPC
En lo que sigue supondremos que H es la matriz de control de un código array y P es la matriz
que mueve cíclicamente b veces las columnas de H, es decir, si consideramos H = [H0 |H1 | . . . |Hn−1 ],
con Hi un bloque de tamaño (nb − kb) × b, entonces HP = [Hn−1 |H0 |H1 | . . . |Hn−2 ]. La ciclicidad
de un código está relacionada con la siguiente propiedad de las columnas de H.
Teorema 2: Un código C con matriz de control H es cíclico si y sólo si existe una matriz invertible
L de tamaño (nb − kb) × (nb − kb) tal que HP = LH.
Teorema 3: Un código C con matriz de control H es cíclico si y sólo si existe una matriz invertible
LP de tamaño (nb − kb) × (nb − kb) tal que HP = LP H, donde LP mueve las filas cíclicamente
(nb − kb)/n posiciones hacia abajo.
Por tanto, como consecuencia inmediata del resultado anterior tenemos el corolario siguiente.
Corolario 1: Sea AH el array de un [n, k]-código array lineal C sobre Fbq . C es cíclico si y sólo si
al sumar (nb − kb)/n a todos los elementos del array, el resultado es un movimiento cíclico en los
columnas de AH .
El ejemplo siguente nos ayudará a entender estos conceptos.
Ejemplo 3: Consideremos el array AH y la matriz H del ejemplo 1. En este caso n = 6, b = 3 y
k = 4, por tanto, si sumamos 1 a todos los elementos del array obtenemos el nuevo array
1
2
3
4
5
0
5, 0 0, 1 1, 2 2, 3 3, 4 4, 5
2, 4 3, 5 4, 0 5, 1 0, 2 1, 3
que se corresponde con la matriz

0 1 0 0 1
 1 0 0 0 1

 0 0 1 1 0

 0 0 0 0 0

 0 0 1 0 0
0 1 0 0 0
0
0
0
1
0
1
0
0
0
1
0
0
0
1
1
0
0
0
1
0
0
0
1
0
0
0
0
0
1
0
0
0
1
1
0
0
0
1
0
0
0
1
0
0
0
0
0
1
0
0
0
1
1
0
1
0
1
0
0
0
1
0
0
0
0
0
0
0
0
0
1
1
0
1
0
1
0
0




,



que se obtiene trasladando el primer bloque al final. Por lo tanto el código que define este array es
un código cíclico.
En nuestro caso, n = br por lo que habrá que sumar 1 a todos los elementos del array, siempre
trabajando sobre Zn . Si nos fijamos en la forma del array (1) y le sumamos una unidad a todos
los elementos del array, observamos que la primera columna se convierte en en la última columna:
1
2
D0 + 1
D0 + 2
D1 + 1
D1 + 2
..
..
.
.
p−1
p−1
D −1 + 1 D −1 + 2
2
2
D p−1 +1 + 1 D p−1 +1 + 2
2
2
..
..
.
.
Db−1 + 1
Db−1 + 2
···
···
···
···
···
···
p−2
0
D0 + p − 2
D0
D1 + p − 2
D1
..
..
.
.
p−1
p−1
D −1 + p − 2 D −1
2
2
D p−1 +1 + p − 2 D p−1 +1
2
2
..
..
.
.
Db−1 + p − 2
Db−1
Este hecho unido con el corolario anterior nos permite afirmar que los códigos obtenidos con
esta construcción son cíclicos.
5
J.-J. Climent y S. Díaz
3.2
MDS
Es bien conocido que para cualquier [n, k, d]-código se satisface que d ≤ n − k + 1. Dicha cota se
conoce con el nombre de cota de Singleton. Si un código alcanza dicha cota con igualdad decimos
que es un código de máxima distancia de separación (MDS).
Teorema 4 (Proposición 2.4 de [8]): Un [n, k]-código lineal C sobre Fq es MDS si y sólo si
n − k columnas de H son linealmente independientes.
La generalización de este resultado para códigos array la proporciona el resultado siguiente.
Corolario 2 (Proposición 3.1 de [5]): Sea H = [H1 |H2 | . . . |Hn ] la matriz de control de un
[n, k]-código array lineal sobre Fbq , con k = n − r, donde cada Hi es de tamaño rb × b sobre Fq .
Entonces C es MDS si y sólo si tomando r submatrices Hi las rb columnas correspondientes forman
un conjunto linealmente independiente sobre Fq .
Nuestro siguiente objetivo es tratar de averiguar si un código array es MDS sin necesidad de
trabajar con una matriz de control. Si queremos ver si un [n, n − r]-código array es MDS a partir
del array, debemos tomar todas las posibles combinaciones de r columnas de éste. Aplicamos el
método de Gauss para todas las combinaciones del array; posteriormente diremos cómo hacerlo.
Si en algunas de las combinaciones el resultado es un array en el que una de las celdas está vacía,
entonces las columnas correspondientes de la matriz de control no son linealmente independientes
y, como indica la proposición anterior, el código no es MDS. En el siguiente ejemplo mostramos
cómo aplicar el método de Gauss por columnas directamente sobre el array, sin necesidad de usar
la matriz.
Ejemplo 4: Tomamos una matriz M y su correspondiente array AM . Aplicamos el método de
Gauss por columnas a la matriz y a su vez vemos que cambios produce cada paso en el array.


1 0 0 0 0 1
 0 1 1 1 0 0 


0
1
 0 1 0 0 0 1 
 −→ AM = 1, 2, 3 3, 4, 5
M =
 0 1 1 0 1 0 


1, 3, 5 0, 2, 4
 0 0 0 0 1 1 
0 0 1 0 1 0
En primer lugar, utilizamos la columna cero para eliminar todos los 1 que hay en la fila cero.
Esto se traduce, en términos de array, en utilizar la celda que contiene al 0 para eliminar todos los
0 de otras celdas. Una vez dado este paso ya no volveremos a utilizar ni a cambiar la columna, o
celda, utilizada (escribimos dichos elementos en negrita). El resultado que obtenemos es:


1 0 0 0 0 0
 0 1 1 1 0 0 


0
1
 0 1 0 0 0 1 

 −→ 1, 2, 3 3, 4, 5
 0 1 1 0 1 0 


1, 3, 5 2, 4
 0 0 0 0 1 1 
0 0 1 0 1 0
A continuación, utilizamos la columna tres, que tiene un 1 en la posición uno, para eliminar
todos los 1 que hay en la fila uno. Esto es, tomaremos la celda que contiene solamente al 1 para
eliminar todos los 1 de otras celdas. El resultado es:


1 0 0 0 0 0
 0 0 0 1 0 0 


0
1
 0 1 0 0 0 1 
 −→ 2, 3 3, 4, 5

 0 1 1 0 1 0 


3, 5 2, 4
 0 0 0 0 1 1 
0 0 1 0 1 0
6
Otra construcción de códigos array cíclicos, MDS y LDPC
Para eliminar los 1 de la fila dos elegimos, por ejemplo, la columna uno. Debemos tener cuidado,
porque esta columna posee un 1 en otra posición, además de en la segunda posición. En términos
de array, esto es, usar el conjunto {2, 3} para eliminar todos los 2 que hay en el resto de celdas, pero
arrastrando el 3, es decir, añadiendo el 3 a las demás celdas que contienen un 2, o eliminándolo si
ya estuviera.


1 1 0 0 0 0
 0 0 0 1 0 0 


0
1
 0 1 0 0 0 0 
 −→ 2,3 3, 4, 5

 0 1 1 0 1 1 


3, 5 3, 4
 0 0 0 0 1 1 
0 0 1 0 1 0
Para eliminar los 1 de la fila tres, podemos elegir la columna dos, la cuatro o la cinco. Elegimos,
por ejemplo, la columna dos. Sucede lo mismo que antes, la columna posee dos 1. En el array
usaremos el conjunto {3, 5} para eliminar todos los 3 que hay en el resto de celdas, pero arrastrando
el 5, es decir, añadiendo el 5 a las demás celdas que contienen un 3, o eliminándolo si ya estuviera.


1 0 0 0 0 0
 0 0 0 1 0 0 


0
1
 0 1 0 0 0 0 
 −→ 2,3 4

 0 1 1 0 0 0 


3,5 4, 5
 0 0 0 0 1 1 
0 0 1 0 0 1
Actuamos de modo similar para los 1 de la fila cuatro. Tomamos la columna cuatro para
eliminar todos los 1 que hay en esta fila. Esto es, tomar la celda que contiene solamente al 4 para
eliminar el resto de 4 que haya en las restantes celdas.


1 0 0 0 0 0
 0 0 0 1 0 0 


0
1
 0 1 0 0 0 0 
 −→ 2,3 4

 0 1 1 0 0 0 


3,5 4, 5
 0 0 0 0 1 0 
0 0 1 0 0 1
Si reordenamos la columnas podemos obtener

1 0 0 0 0 0
 0 1 0 0 0 0

 0 0 1 0 0 0

 0 0 1 1 0 0

 0 0 0 0 1 0
0 0 0 1 0 1
la forma escalonada de la matriz.




 −→



0 3, 5
1
4
2, 3 5
Una vez que ya sabemos como aplicar el método de Gauss a un array, sin necesidad de implementar la matriz correspondiente, podemos saber si un código array es MDS siguiendo los pasos
mencionados anteriormente.
Ejemplo 5: Consideremos el código cuyo array es
AH =
0
1
2
3
4
5
1, 2, 5 2, 3, 0 3, 4, 1 4, 5, 2 5, 0, 3 0, 1, 4
y comprobemos si es MDS. Los parámetros del código
son n = 6, k = 3, r = 3 y b = 2. Tenemos
que aplicar el método de Gauss para todas las nr = 20 combinaciones posibles de columnas. En
7
J.-J. Climent y S. Díaz
este caso el código no es MDS, ya que obtenemos una combinación en la que al aplicar el método
de Gauss obtenemos una columna completamente nula:
0
1
4
1, 2, 5 2, 3, 0 5, 0, 3
Gauss
−→
0
1
4
2, 5 3, 5 −−
Queda por establecer una demostración formal de las condiciones que deben cumplir los parámetros para poder afirmar que el código es MDS.
Agradecimientos
Este trabajo ha sido parcialmente subvencionado por el proyecto MTM2008-06674-C02-01 del
Ministerio de Ciencia e Innovación del Gobierno de España. Además, la investigación de Sara Díaz
ha sido financiada con una ayuda de la Generalitat Valenciana destinada a la formación de doctores
(Ref. BFPI/2008/138).
Referencias
[1] M. Blaum, J. Brady, J. Bruck y J. Menon. EVENODD: An efficient scheme for tolerating double
disk failures in RAID architectures. IEEE Transactions on Computers, 42(2): 192–202 (1995).
[2] M. Blaum, J. Bruck y A. Vardy. MDS array codes with independent parity symbols. IEEE
Transactions on Information Theory, 42(2): 529–542 (1996).
[3] M. Blaum, P. G. Farrell y H. C. A. van Tilborg. Array codes. En V. S. Pless y W. C.
Huffman (editores), Handbook of Coding Theory, páginas 1855–1909. Elsevier, North-Holland, 1998.
[4] M. Blaum y R. M. Roth. New array codes for multiple phased burst correction. IEEE Transactions
on Information Theory, 39(1): 66–77 (1993).
[5] M. Blaum y R. M. Roth. On lowest density MDS codes. IEEE Transactions on Information
Theory, 45(1): 46–59 (1999).
[6] K. Huber. Some comments on Zech’s logarithms. IEEE Transactions on Information Theory,
36(4): 946–950 (1990).
[7] E. Louidor y R. M. Roth. Lowest density MDS codes over extension alphabets. IEEE Transactions
on Information Theory, 52(7): 46–59 (2006).
[8] F. J. MacWilliams y N. J. A. Sloane. The Theory of Error-Correcting Codes. North-Holland,
Amsterdam, 6a edición, 1988.
[9] L. Xu y J. Bruck. X-code: MDS array codes with optimal encoding. IEEE Transactions on
Information Theory, 45(1): 272–276 (1999).
[10] V. Xu, Lihao Bohossian, J. Bruck y D. G. Wagner. Low-density MDS codes and factors of
complete graphs. IEEE Transactions on Information Theory, 45(6): 1817–1826 (1999).
8