¿Cómo se determina el número de errores en el algoritmo Welch-Berlekamp?

En el algoritmo de Welch-Berlekamp para decodificar códigos Reed-Solomon, a uno se le da una lista de puntos $(a_i, b_i)$ representan un mensaje con errores $e$ en $b_i$ en ubicaciones desconocidas (y $e$ se le da al algoritmo). La salida es un polinomio que pasa por todos los puntos dados, excepto aquellos en los que se produjeron errores.

El método implica resolver un sistema de ecuaciones lineales de la forma

b_{i} E (a_{i}) = Q (a_{i})

$b_i E(a_i) = Q(a_i)$

para toda $i$ , donde $E$ tiene un grado $e$ y $Q$ tiene un grado en la mayoría $e+k$ . Las variables son los coeficientes de $E$ y $Q$ .

Para asegurarse de que $E$ tenga un grado $e$ generalmente se agrega la restricción de que el coeficiente de $x^e$ es 1 al sistema lineal anterior. Sin embargo, en la práctica uno no necesariamente sabe $e$ . Una forma ineficiente (pero aún de tiempo polinomial) de lidiar con esto es probar $e$ para todos los valores que comienzan con $(n+k-1)/2 - 1$ bajando hasta encontrar una solución.

Mi pregunta es: ¿hay una forma más eficiente de determinar ? $e$ Alternativamente, ¿hay alguna modificación en el sistema lineal que le permita a uno usar un límite superior en lugar del valor exacto? $e$

En particular, quiero usar este decodificador específico para códigos Reed-Solomon, y no un algoritmo completamente diferente basado en otras técnicas.

En respuesta a la respuesta de DW, aquí está mi ejemplo de trabajo. Todo se hace módulo 7.

plain message is: [2, 3, 2]
polynomial is: 2 + 3 t^1 + 2 t^2
encoded message is: [[0, 2], [1, 0], [2, 2], [3, 1], [4, 4]]
corrupted message is: [[0, 2], [1, 0], [2, 3], [3, 1], [4, 4]]

Entonces el error está en el tercer punto.

Cuando la ecuación polinómica en cuestión es $e=2$

b_{i} (e_{0} + e_{1} x + e_{2} x^{2}) - q_{0} - q_{1} x - q_{2} x^{2} - q_{3} x^{3} - q_{4} x^{4} = 0

$b_i(e_0 + e_1x + e_2x^2) - q_0 - q_1x - q_2 x^2 - q_3x^3 - q_4x^4 = 0$

Y al enchufar obtiene el sistema en forma de matriz: $x = 0,1,2,3,4$

[2, 0, 0, 6, 0, 0, 0, 0, 0]
[0, 0, 0, 6, 6, 6, 6, 6, 0]
[3, 6, 5, 6, 5, 3, 6, 5, 0]
[1, 3, 2, 6, 4, 5, 1, 3, 0]
[4, 2, 1, 6, 3, 5, 6, 3, 0]
[0, 0, 1, 0, 0, 0, 0, 0, 1]

La última fila es la restricción de que . Aplicando la eliminación gaussiana obtenemos $e_2 = 1$

[1, 0, 0, 0, 0, 0, 1, 4, 0]
[0, 1, 0, 0, 0, 0, 3, 3, 1]
[0, 0, 1, 0, 0, 0, 0, 0, 1]
[0, 0, 0, 1, 0, 0, 2, 1, 0]
[0, 0, 0, 0, 1, 0, 2, 2, 5]
[0, 0, 0, 0, 0, 1, 4, 5, 2]

Y eligiendo 1 para ambas variables libres obtenemos un vector de solución de

[2, 2, 1, 4, 1, 0, 1, 1]

Lo que se traduce en

E is 2 + 2 t^1 + 1 t^2
Q is 4 + 1 t^1 + 0 t^2 + 1 t^3 + 1 t^4

Y no divide . Tenga en cuenta que factores como $E$ $Q$ $Q$ $(t + 6) (t^3 + 2t^2 + 2t + 3) \mod 7$

Para obtengo una buena solución: $e=1$

system is:    
[2, 0, 6, 0, 0, 0, 0]
[0, 0, 6, 6, 6, 6, 0]
[3, 6, 6, 5, 3, 6, 0]
[1, 3, 6, 4, 5, 1, 0]
[4, 2, 6, 3, 5, 6, 0] 
[0, 1, 0, 0, 0, 0, 1]

reduced system is:

[1, 0, 0, 0, 0, 0, 5]
[0, 1, 0, 0, 0, 0, 1]
[0, 0, 1, 0, 0, 0, 3]
[0, 0, 0, 1, 0, 0, 3]
[0, 0, 0, 0, 1, 0, 6]
[0, 0, 0, 0, 0, 1, 2]

solution is [5, 1, 3, 3, 6, 2]
Q is 3 + 3 t^1 + 6 t^2 + 2 t^3
E is 5 + 1 t^1
P(x) = 2 + 3 t^1 + 2 t^2 # this is correct!
r(x) = 0

Tenga en cuenta que si bien el contraejemplo anterior fue generado por el código que escribí desde cero (básicamente fue lo primero que probé), uno puede verificar que las soluciones sean válidas a mano, por lo que incluso si mi código tiene errores, sigue siendo un contraejemplo válido para el reclamo que usando funciona. $e=2$

algorithms error-correcting-codes

— JeremyKun
fuente

@DW, el vector solución es válido. En realidad, es 1 * 2 + 1 * 1 + 4 * 1 (la dimensionalidad del vector solución es única porque la última columna de la matriz se omite). Mi omisión de

es un error tipográfico en la escritura aquí, pero es correcto en mi implementación. Puede ver su efecto, por ejemplo, en la segunda fila del sistema que usa el punto [1, 0], y los primeros tres entires son todos cero porque se multiplican por 0. Si mi ejemplo no está claro, puedo publicar mi código en github Considero que mi código está limpio, pero sería más complicado debido a su generalidad.

b_{i}

$b_i$

— JeremyKun

El mismo procedimiento realmente funciona para corregir cualquier número de errores hasta . $e$

El requisito es que el polinomio de error tenga que ser cero en cada punto donde haya un error. Nada dice que tiene que ser cero solo en esos puntos; también puede tener una que sea cero en otros puntos, y eso está bien, siempre que su grado sea . $E(x)$ $a_i$ $E(x)$ $e$

Entonces, si es un límite superior en el número de errores, existirá un polinomio con todas las propiedades deseadas (es decir, tiene un grado exactamente $e$ $E(x)$ y es cero en cada punto donde hay un error). Por ejemplo, si hay menos de errores, entonces existe un polinomio que es cero en cada error, y cero en algunos puntos más para obtener el número de ceros hasta exactamente . $e$ $e$ $E(x)$ $e$

Finalmente, el teorema de corrección dice que si existe tal polinomio , entonces el algoritmo de Berlekamp-Welch podrá encontrarlo. Entonces, incluso si hay menos de errores, el procedimiento seguirá funcionando correctamente para identificar $E(x)$ $e$ . Una vez que tenga , puede identificar posiciones que están libres de errores, y luego puede decodificar de manera directa. $E(x)$ $E(x)$ $n-e$

Para documentar el resultado de la conversación sobre el "contraejemplo" en la pregunta:

$n-k+1$ $(n-k)/2$ $n=5$ $k=3$ $(n-k)/2=1$ $e=1$ $e=2$

Entonces, el contraejemplo no es en realidad un contraejemplo, y no contradice mi respuesta anterior.

— DW
fuente

n - k + 1

$n-k+1$

(n - k) / 2

$(n-k)/2$

E (x)

$E(x)$

E (x)

$E(x)$

n = 7

$n = 7$

e = 2

$e=2$

Bien, esto funciona en los ejemplos que estoy probando. ¡Excelente!

— JeremyKun