Làm thế nào để bạn xác định số lượng lỗi trong thuật toán Welch-Berlekamp?

Trong thuật toán Welch-Berlekamp để giải mã mã Reed-Solomon, người ta sẽ đưa ra một danh sách các điểm đại diện cho một thông báo có lỗi trên ở các vị trí không xác định (và được đưa cho thuật toán). Đầu ra là một đa thức đi qua tất cả các điểm đã cho ngoại trừ những điểm xảy ra lỗi.e b i$(a_i, b_i)$$e$$b_i$$e$

Phương pháp này bao gồm việc giải một hệ phương trình tuyến tính có dạng

với tất cả trong đó có độ và có độ lớn nhất là . Các biến là các hệ số của và .E e Q e + k E $i$$E$$e$$Q$$e+k$$E$$Q$

Để đảm bảo rằng có độ người ta thường thêm ràng buộc rằng hệ số của là 1 với hệ thống tuyến tính ở trên. Tuy nhiên, trong thực tế người ta không nhất thiết phải biết . Một cách không hiệu quả (nhưng vẫn là thời gian đa thức) để giải quyết vấn đề này là thử cho tất cả các giá trị bắt đầu bằng đi xuống cho đến khi tìm thấy giải pháp.e x e e e ( n + k - 1 ) / 2 - $E$$e$$x^e$$e$$e$$(n+k-1)/2 - 1$

Câu hỏi của tôi là: có cách nào hiệu quả hơn để xác định không? $e$Ngoài ra, có một sửa đổi cho hệ thống tuyến tính cho phép một người sử dụng giới hạn trên trên thay vì giá trị chính xác?$e$

Cụ thể, tôi muốn sử dụng bộ giải mã cụ thể này cho các mã Reed-Solomon, và không phải là một thuật toán hoàn toàn khác dựa trên các kỹ thuật khác.

Đáp lại câu trả lời của DW, đây là ví dụ làm việc của tôi. Tất cả mọi thứ được thực hiện 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]]

Vì vậy, lỗi là ở điểm thứ ba.

Khi phương trình đa thức trong câu hỏi là$e=2$

Và cắm cho hệ thống ở dạng ma trận:$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]

Hàng cuối cùng là ràng buộc mà . Áp dụng loại bỏ Gaussian chúng ta nhận được$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]

Và chọn 1 cho cả hai biến miễn phí, chúng ta có một vectơ giải pháp là

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

Dịch ra

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

Và không chia . Lưu ý rằng các yếu tố là$E$$Q$$Q$$(t + 6) (t^3 + 2t^2 + 2t + 3) \mod 7$

Với tôi nhận được một giải pháp tốt:$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

Lưu ý rằng mặc dù mẫu phản ứng ở trên được tạo bởi mã tôi đã viết từ đầu (về cơ bản đó là điều đầu tiên tôi đã thử), người ta có thể kiểm tra các giải pháp là hợp lệ bằng tay, vì vậy ngay cả khi mã của tôi bị lỗi, nó vẫn là một ví dụ hợp lệ cho khiếu nại sử dụng hoạt động.$e=2$

Quy trình tương tự thực sự hoạt động để sửa bất kỳ số lỗi nào lên đến .$e$

Yêu cầu là đa thức phải bằng 0 tại mọi điểm khi có lỗi. Không có gì nói rằng nó phải bằng không tại những điểm đó; bạn cũng có thể có bằng 0 tại các điểm khác và không sao, miễn là mức độ của nó là .$E(x)$$a_i$$E(x)$$e$

Vì vậy, nếu là giới hạn trên của số lỗi, sẽ tồn tại đa thức với tất cả các thuộc tính mong muốn (nghĩa là có độ chính xác và bằng 0 tại mọi điểm có lỗi). Chẳng hạn, nếu có ít hơn lỗi , thì tồn tại một đa thức không có lỗi ở mọi lỗi và 0 tại một vài điểm nữa để có được số 0 lên chính xác cho .$e$$E(x)$$e$$e$$E(x)$$e$

Cuối cùng, định lý đúng cho biết rằng nếu một đa thức tồn tại, thì thuật toán Berlekamp-Welch sẽ có thể tìm thấy nó. Vì vậy, ngay cả khi có ít hơn lỗi , quy trình vẫn sẽ hoạt động chính xác để xác định . Khi bạn có , bạn có thể xác định các vị trí không có lỗi và sau đó bạn có thể giải mã theo cách đơn giản.$E(x)$$e$$E(x)$$E(x)$$n-e$

Để ghi lại kết quả của cuộc trò chuyện về "mẫu phản" trong câu hỏi:

Đó thực sự không phải là một ví dụ hợp lệ. Lỗ hổng nằm ở việc tính toán có bao nhiêu lỗi mà bạn mong đợi Berlekamp-Welch có thể sửa được. Khoảng cách là , vì vậy bạn nên mong đợi nó có thể sửa tối đa lỗi (như Ran G. chỉ ra). Trong ví dụ của bạn và , vì vậy , vì vậy bạn chỉ nên mong đợi quy trình này có thể sửa một lỗi, tức là . Vì vậy, khi bạn chạy quy trình trên một ví dụ với , không có lý do gì để mong đợi quy trình hoạt động chính xác.( n - k ) / 2 n = 5 k = 3 ( n - k ) / 2 = 1 e = 1 e = $n-k+1$$(n-k)/2$$n=5$$k=3$$(n-k)/2=1$$e=1$$e=2$

Vì vậy, ví dụ mẫu không thực sự là mẫu phản và nó không mâu thuẫn với câu trả lời của tôi ở trên.