伽罗瓦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()三、运行结果截图：
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
