伽罗瓦2^8域下模多项式求逆python（查表）实现

伽罗瓦2^8域下模多项式求逆python（查表）实现

一、实验原理：

二、实现代码：

import time
#提取多项式的方幂信息及对应系数，返回对应列表，形如：[2,3,1,0,1]对应多项式2x^4+3x^3+x^2+1
def extract_info(str_polynimial):
    length=len(str_polynimial)
    add=1       #记录加号位置
    for i in range(length):
        if i==0:        #获取x的最高次幂指数及其系数
            j=0
            while(j!=length and str_polynimial[j]!='x'):
                j+=1
            if j+1==length or str_polynimial[j+1]!='^':
                index_list = [0] *2
                str_coefficient = "".join([str(item) for item in str_polynimial[0:j]])
                if str_coefficient=="":
                    str_coefficient='1'
                index=1
                index_list[index] = int(str_coefficient)
            elif str_polynimial[j+1]=='^':
                k=j+2
                while(k!=length and str_polynimial[k]!='+' and str_polynimial[k]!='-'):
                    k+=1
                str_index = "".join([str(item) for item in str_polynimial[j+2:k]])
                highest_index = int(str_index)  # 获取最高次幂指数
                index_list = [0] * (highest_index + 1)
                index = highest_index
                if j == 0:  # 首项系数为1的情况下
                    index_list[index] = 1
                else:
                    str_coefficient = "".join([str(item) for item in str_polynimial[0:j]])
                    index_list[index] = int(str_coefficient)

        elif str_polynimial[i]!='+' and str_polynimial[i]!='-':
            continue
        else:
            j = i
            while (j!=length and str_polynimial[j] != 'x'):
                j += 1
            #截取x某一方幂前的系数
            str_coefficient = "".join([str(item) for item in str_polynimial[i+1:j]])
            if str_coefficient=="":     #如果str_coefficient未截取到字符串，证明该项系数为1，令str_coefficient='1'
                str_coefficient='1'
            if str_polynimial[i]=='-':      #如若系数为负，更正系数
                str_coefficient="-"+str_coefficient
            #下面确定并截取x的方幂次数
            if j==length:       #如果已遍历至字符串末位，证明x对应方幂为0
                str_index='0'
            elif (j+1)==length or str_polynimial[j+1]=='+'or str_polynimial[j+1]=='-':        #如果x紧接着的字符为’+‘或此时x为最后一个字符，则证明该x对应的方幂次数为1
                str_index = '1'
            else:
                k=j+2
                while(k!=length and str_polynimial[k]!='+' and str_polynimial[k]!='-'):
                    k+=1
                #while语句执行完后，str_polynimial[k]='+'
                str_index="".join([str(item) for item in str_polynimial[j+2:k]])        #截取x对应的方幂次数
            #修改列表对应参数
            index_list[int(str_index)]=int(str_coefficient)
    index_list.reverse()
    return index_list

#将列表转换为多项式，如[2,1,0,12]将被转换为字符串"2x^3+x^2+12"
def translation(list):
    str_polynimial=""
    for i in range(len(list)):
        if list[i]==0:
            continue
        index=len(list)-i-1       #获取方幂次数
        coefficient=list[i]       #获取对应x某一方幂的系数
        if index==0:
            string=str(coefficient)
        elif index==1:
            if coefficient==1:
                string = 'x'
            else:
                string=str(coefficient)+'x'
        else:
            if coefficient==1:
                string = 'x' + '^' + str(index)
            else:
                string=str(coefficient)+'x'+'^'+str(index)
        if i==0 or list[i]<0:
            str_polynimial=str_polynimial+string
        elif list[i]>0:
            str_polynimial=str_polynimial+'+'+string

    if str_polynimial=="":
        str_polynimial="0"
    return str_polynimial

#定义多项式列表与数的乘法，参数list为被乘的多项式列表，a为int型的乘数。计算数域为Zp
def Multiplication(list,a):
    result=[]
    for i in range(len(list)):
        result.append(list[i]*a%2)
    return result

#定义多项式与多项式的乘法，参数list1，list2均为多项式的列表表示法。计算数域为Zp
def Multiplication2(list1,list2):
    a=list1.copy()
    b=list2.copy()
    result=[0]
    for i in range(len(b)):
        product=Multiplication(a,b[i])
        product.extend([0]*(len(b)-1-i))
        result=Add(result,product)
    return result

#定义多项式列表表示的减法，要求参数list1与list2等长，返回结果仍为等长的列表。计算数域为Zp
def Subtraction(list1,list2):
    a=list1.copy()
    b=list2.copy()
    result=[]
    for i in range(len(a)):
        result.append((a[i]-b[i])%2)
    return result

#计算数域为Zp
def Subtraction2(list1,list2):
    a=list1.copy()
    b=list2.copy()
    if len(a)<len(b):
        a.reverse()
        a.extend([0]*(len(b)-len(a)))
        a.reverse()
    elif len(a)>len(b):
        b.reverse()
        b.extend([0] * (len(a) - len(b)))
        b.reverse()
    result=Subtraction(a,b)
    return result

#定义多项式的加法，默认参数list1、list2不等长
def Add(list1,list2):
    a=list1.copy()
    b=list2.copy()
    result=[]
    if len(a)>len(b):
        b.reverse()
        b.extend([0]*(len(a)-len(b)))
        b.reverse()
        max=len(a)
    else:
        a.reverse()
        a.extend([0]*(len(b)-len(a)))
        a.reverse()
        max=len(b)
    for i in range(max):
        result.append((a[i]+b[i])%2)
    for j in range(len(result)):  # 除去列表最左端无意义的0
        if result[0] == 0:
            result.remove(0)
        else:
            break
    return result

#实现多项式带余除法,参数list1、list2均为列表，list1为被除多项式返回多项式商q的列表与余式r的列表
def Division(list1,list2):
    #此处注意要深拷贝，浅拷贝会修改传进来的参数值
    r=list1.copy()
    b=list2.copy()
    if len(r)<len(b):
        return [0],list1
    q=[0]*(len(r)-len(b)+1)
    for i in range(len(q)):
        if len(r)>=len(b):
            index = len(r) - len(b) + 1  # 确定所得商是商式的第index位
            q[-index] = int(r[0] / b[0])
            # 更新被除多项式
            b_=b.copy()
            b_.extend([0] * (len(r) - len(b)))
            b_=Multiplication(b_,q[i])
            r = Subtraction(r ,b_)
            for j in range(len(r)):     #除去列表最左端无意义的0
                if r[0]==0:
                    r.remove(0)
                else:
                    break
        else:
            break
    return q,r

#定义28域下多项式的乘法，正常多项式乘法，再模去特定不可约多项式（记为w），运行时将内置为[1,0,1,1,0,0,0,1,1]
def G28_Multiplication(list1,list2,w):
    a=list1.copy()
    b=list2.copy()
    Mul=Multiplication2(a,b)
    _,r=Division(Mul,w)
    return r

#扩展欧几里得算法，输入两个多项式列表list1、list2，返回二者的最大公因式列表d，以及满足d=u*list1+v*list2的u和v
#默认list1、list2不等于0
def Extend_Euclid(list1,list2,p):
    f=list1.copy()
    g=list2.copy()
    u_2=[1]
    u_1=[0]
    v_2=[0]
    v_1=[1]
    while(g!=[]):
        q,r=Division(f,g)
        u=Subtraction2(u_2,Multiplication2(q,u_1))
        v=Subtraction2(v_2,Multiplication2(q,v_1))
        f,g=g,r
        u_2,u_1=u_1,u
        v_2,v_1=v_1,v

    d,u,v=f,u_2,v_2
    return d,u,v

#将多项式列表转换为10进制编号
def tran_2_to_10(list):
    result=0
    for i in range(len(list)):
        if list[i]==1:
            result+=2**(len(list)-1-i)
    return result

def tran_10_to_2_list(number_code):
    list=[]
    number=number_code
    while(number!=0):
        r=number%2
        list.append(int(r))
        number=(number-r)/2
    list.reverse()
    return list

def test():
    w = [1, 0, 1, 1, 0, 0, 0, 1, 1]  # 内置的八次不可约多项式
    x = [1, 0]  # 内置的本原元多项式
    table = [1]
    # table_F中存储有256域下面各编号元素对应的生成元的次数，次数为列表中对应序号元素的值，
    # 例:生成元x的table_F[4]次方，生成元素4（多项式表示为x^2）
    table_F = [0] * 256
    for i in range(255):
        if i == 254:  # 约定第255号生成元素0
            table.append(0)
            table_F[0] = 255
            break
        _, item = Division(x, w)  # item为本原元生成的256域下的多项式元素
        number = tran_2_to_10(item)
        table_F[number] = i + 1
        table.append(number)
        x.append(0)
    print("GF(256)域下，建立指数对数表如下：")
    # 将256域中的元素按十进制排序，存储在tabel_F列表中
    for i in range(len(table)):print("{:<4}".format(i), end=' ')
    print("\n")
    for j in table:print("{:<4}".format(j), end=' ')
    print("\n")
    for k in table_F:print("{:<4}".format(k), end=' ')
    print("\n******************************************************************************")
    a = input("请输入第一个多项式：")
    list_a = extract_info(a)
    a_number = tran_2_to_10(list_a)
    b = input("请输入第二个多项式：")
    list_b = extract_info(b)
    b_number = tran_2_to_10(list_b)
    num_product = table[(table_F[a_number] + table_F[b_number]) % 255]  # 获得两多项式积在256域中的编号
    list_product = tran_10_to_2_list(num_product)
    str_product = translation(list_product)  # 将对应多项式输出
    inverse_a = table[255 - table_F[a_number]]
    list_inverse = tran_10_to_2_list(inverse_a)
    str_inverse_a = translation(list_inverse)
    print("GF（256）下两多项式之积为："+str_product)
    print("GF（256）下多项式"+a+"的逆元为："+str_inverse_a)
    return 0

if __name__ == '__main__':
    test()

三、运行结果截图：