Come si determina il numero di errori nell'algoritmo Welch-Berlekamp?

Nell'algoritmo Welch-Berlekamp per la decodifica dei codici Reed-Solomon, viene fornito un elenco di punti $(a_i, b_i)$ rappresentano un messaggio con errori $e$ su $b_i$ in posizioni sconosciute (ed $e$ viene dato all'algoritmo). L'output è un polinomio che passa attraverso tutti i punti dati tranne quelli in cui si sono verificati errori.

Il metodo prevede la risoluzione di un sistema di equazioni lineari della forma

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

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

per tutti $i$ cui $E$ ha grado $e$ e $Q$ ha grado massimo $e+k$ . Le variabili sono i coefficienti di $E$ e $Q$ .

Per garantire che $E$ ha grado $e$ uno di solito aggiunge il vincolo che il coefficiente di $x^e$ è 1 per il sistema lineare di cui sopra. Tuttavia, in pratica non si conosce necessariamente $e$ . Un modo inefficiente (ma ancora tempo polinomiale) di gestirlo è provare $e$ per tutti i valori che iniziano con $(n+k-1)/2 - 1$ che scende fino a trovare una soluzione.

La mia domanda è: esiste un modo più efficiente per determinare ? $e$ In alternativa, esiste una modifica al sistema lineare che consente di utilizzare un limite superiore su anziché il valore esatto? $e$

In particolare, voglio usare questo decodificatore specifico per i codici Reed-Solomon e non un algoritmo completamente diverso basato su altre tecniche.

In risposta alla risposta di DW, ecco il mio esempio di lavoro. Tutto è fatto modulo 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]]

Quindi l'errore è nel terzo punto.

Quando l'equazione polinomiale in questione $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$

E collegando ottiene il sistema in forma di matrice: $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]

L'ultima riga è il vincolo che . Ottenendo l'applicazione dell'eliminazione gaussiana $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]

E selezionando 1 per entrambe le variabili libere otteniamo un vettore di soluzione

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

Che si traduce in

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

E non divide . Si noti che $E$ $Q$ $Q$ fattori come $(t + 6) (t^3 + 2t^2 + 2t + 3) \mod 7$

Per ottengo una buona soluzione: $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

Si noti che mentre il controesempio sopra è stato generato dal codice che ho scritto da zero (era sostanzialmente la prima cosa che ho provato), si può verificare che le soluzioni siano valide a mano, quindi anche se il mio codice è difettoso è ancora un controesempio valido per il reclamo che usando funziona. $e=2$

algorithms error-correcting-codes

— JeremyKun
fonte

@DW il vettore della soluzione è valido. In realtà è 1 * 2 + 1 * 1 + 4 * 1 (la dimensionalità del vettore della soluzione è una tantum perché l'ultima colonna della matrice è esclusa). Il mio lasciare fuori il

è un errore di battitura nel writeup qui, ma è corretto nella mia implementazione. Puoi vedere il suo effetto, ad esempio, nella seconda riga del sistema che utilizza il punto [1, 0], e i primi tre impegni sono tutti zero perché moltiplicati per 0. Se il mio esempio non è chiaro, posso pubblicare il mio codice su github. Considero il mio codice pulito, ma sarebbe più disordinato a causa della sua generalità.

b_{i}

$b_i$

— JeremyKun,

La stessa procedura funziona effettivamente per correggere qualsiasi numero di errori fino a . $e$

Il requisito è che l'errore polinomiale debba essere zero in ogni punto cui si è verificato un errore. Nulla dice che deve essere zero solo in quei punti; puoi avere un $E(x)$ $a_i$ che è zero anche in altri punti, e va bene, purché il suo grado sia . $E(x)$ $e$

Quindi, se è un limite superiore al numero di errori, esisterà un polinomio con tutte le proprietà desiderate (ovvero, ha grado esattamente ed è zero in ogni punto in cui si verifica un errore). Ad esempio, se ci sono meno di errori , allora esiste un polinomio che è zero ad ogni errore e zero in alcuni punti in più per portare il numero di zeri fino a . $e$ $E(x)$ $e$ $e$ $E(x)$ $e$

Infine, il teorema di correttezza afferma che se esiste un tale polinomio , allora l'algoritmo di Berlekamp-Welch sarà in grado di trovarlo. Quindi, anche se ci sono meno di errori, la procedura continuerà a funzionare correttamente per identificare . Una volta che hai , puoi identificare le posizioni che sono prive di errori e quindi puoi decodificare in modo semplice. $E(x)$ $e$ $E(x)$ $E(x)$ $n-e$

Per documentare il risultato della conversazione sul "controesempio" nella domanda:

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

Quindi, il controesempio non è in realtà un controesempio e non contraddice la mia risposta sopra.

— DW
fonte

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$

Ok, questo funziona con gli esempi su cui ci sto provando. Eccellente!

— JeremyKun,