Berlekamp-Massey算法在二元域上的Python实现

Berlekamp-Massey算法

本文介绍了Berlekamp-Massey算法流程以及对应的一个二元域上的Python实现。
注：本文的实现不适用于$a_0\ne 0$的序列

前置知识

线性综合解

如何理解退化的线性移位寄存器？

在非退化的线性移位寄存器中，我们有$\mathrm{deg}(f_N(x))=l_N$,即生成线性移位寄存器序列时，新生成的位一定依赖当前状态中的第一位。

例：0011101的线性综合解为$(1+x+x^3,3)$

给0011101编为$a_0{a}_1{a}_2{a}_3{a}_4{a}_5{a}_6$,则初态应该有3位，是$a_0{a}_1{a}_2$即001

注意线性综合解中的多项式是联接多项式(也叫反馈多项式)，通过对其求互反多项式可以求得线性移位寄存器序列的特征多项式。

求互反多项式：将联接多项式中的$x$换成$\frac{1}{x}$，再乘以$x^{l_N}$

$(1+\frac{1}{x}+\frac{1}{x^3})x^3=x^3+x^2+1$,所以依据特征多项式的定义知$a_{n+3}=a_{n+2}+a_n$

后面生成新的位的过程应该是：$a_3=a_2+a_0=1+0=1$，依此类推

而退化的线性移位寄存器序列的生成不依赖当前状态的第一位。

例：00101101的线性综合解为$(1+x+x^2,4)$

初态为$a_0{a}_1{a}_2{a}_3$即0010

同理，$a_4=a_3+a_2=0+1=1,a_5=a_4+a_3=1+0=1$，依此类推

算法流程

该算法可以求出关于给定有限长序列$a^{(N)}$的线性综合解。

算法实现思路

给定一个0-1序列(二元域，考虑取余)（采用0,1列表表示）

(1)初始化：

找到第一个不等于0的位作为$a_{n_0}$,顺序查找

$a_0=a_1=...=a_{n_0-1}=0$

取$d_0=d_1=...=d_{n_0-1}=0,d_{n_0}=a_{n_0}$，需要存储

令$f_1(x)=f_2(x)=...=f_{n_0}(x)=1$

$l_1=l_2=..=l_{n_0}=0$，需要存储

令$f_{n_0+1}(x)=1-d_{n_0}{x}^{n_0+1},l_{n_0+1}=n_0+1$,

设计多项式类，设计线性综合解二元组类

(2)迭代计算：(for循环)

假设$(f_i(x),l_i),1\le i\le n$已经求得。

令$f_n(x)=1+c_{n,1}x+...+c_{n,l_n}{x}^{l_n}$

计算$d_n=a_n+c_{n,1}{a}_{n-1}+...+c_{n,l_n}{a}_{n-l_n}$

if判断

如果$d_n=0$，取$f_{n+1}(x)=f_n(x),l_{n+1}=l_n$

如果$d_n\ne 0$,存在$1\le m<n$

使$l_m<l_{m+1}=l_{m+2}=...=l_n$

找到最后一个$m$，顺序查找

取$f_{n+1}(x)=f_n(x)-d_n{d}_m^{-1}{x}^{n-m}{f}_m(x)$

l n + 1 = m a x { l n , n + 1 − l n } l_{n+1}=max\{l_n,n+1-l_n\} ln+1​=max{ln​,n+1−ln​}

需要实现多项式的加法

因为只考虑二元域，所以这里的系数的加法都模2取余，且不进位（采用异或实现），算法中的减法统一替换成加法。

算法代码

# author:njw
# 二元域上的Berlekamp-Massey算法

# 二元域上的多项式类
class Polynomial:
    def __init__(self, coefficients):
        self.coefficients = coefficients
        self.degree = len(coefficients) - 1

    # 二元域上的多项式的加法，做异或运算
    def __add__(self, other):
        if self.degree > other.degree:
            return Polynomial(
                [
                    self.coefficients[i] ^ other.coefficients[i]
                    for i in range(other.degree + 1)
                ]
                + self.coefficients[other.degree + 1 :]
            )
        else:
            return Polynomial(
                [
                    self.coefficients[i] ^ other.coefficients[i]
                    for i in range(self.degree + 1)
                ]
                + other.coefficients[self.degree + 1 :]
            )


# 线性综合解类（用于存储线性综合解）（二元组）
class LinearCombinationSolution:
    def __init__(self, polynomial, order):
        self.polynomial = polynomial
        self.order = order


# 二元域上的Berlekamp-Massey算法
# 输入：0-1序列(采取0-1列表表示)
def Berlekamp_Massey_algorithm(sequence):
    # 初始化
    n = 0
    # 找到第一个不等于0的位
    for i in range(len(sequence)):
        if sequence[i] == 1:
            n = i
            break

    d = [0 for i in range(n)]
    d.extend([1])

    linear_combination_solutions = []
    for i in range(n):
        linear_combination_solutions.append(
            LinearCombinationSolution(Polynomial([1]), 0)
        )

    linear_combination_solutions.append(
        LinearCombinationSolution(Polynomial([1] + [0 for i in range(n)] + [1]), n + 1)
    )

    # 迭代
    for i in range(n, len(sequence) - 1):
        # 计算新的d
        temp_d = 0
        for j in range(linear_combination_solutions[-1].polynomial.degree + 1):
            temp_d += (
                linear_combination_solutions[-1].polynomial.coefficients[j]
                * sequence[i - j + 1]
            )

        temp_d = temp_d % 2
        d.append(temp_d)
        # 如果d为0，那么线性综合解不变
        if temp_d == 0:
            linear_combination_solutions.append(linear_combination_solutions[-1])
        # 如果d不为0，那么线性综合解更新
        else:
            m = len(linear_combination_solutions) - 1
            # 寻找当前最后一个跳跃的l
            for k in range(len(linear_combination_solutions)):
                if (
                    linear_combination_solutions[m - k].order
                    < linear_combination_solutions[-1].order
                ):
                    # 更新线性综合解
                    linear_combination_solutions.append(
                        LinearCombinationSolution(
                            # 更新线性综合解的联接多项式
                            linear_combination_solutions[-1].polynomial.__add__(
                                Polynomial(
                                    [0 for l in range(i - m + k)]
                                    + linear_combination_solutions[
                                        m - k
                                    ].polynomial.coefficients
                                )
                            ),
                            # 更新线性综合解的阶
                            max(
                                linear_combination_solutions[-1].order,
                                i + 2 - linear_combination_solutions[-1].order,
                            ),
                        )
                    )
                    break
    return linear_combination_solutions[-1]
# 返回线性综合解的联接多项式和阶

# 测试
if __name__ == "__main__":
    # test1
    # sequence = [0,0,1,0,1,1,0,1]
    # test2
    sequence = [0,0,1,1,1,0,1]
    # test3 都是用之前编写的LFSR产生的序列
    # sequence = [0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1]
    # test4
    # sequence = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1]
    # test5
    # sequence = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,1]
    # sequence =[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,0,0,1,1,1]
    linear_combination_solution = Berlekamp_Massey_algorithm(sequence)
    print(linear_combination_solution.polynomial.coefficients)
    print(linear_combination_solution.order)
    # 结果说明：[1,1,0,1],3是指联接多项式为1+x+x^3，阶为3