Cómo realizar la suma y multiplicación en F_{2^8}.
Quiero realizar sumas y multiplicaciones en F_{2^8}
Actualmente tengo este código que parece funcionar para la suma pero no funciona para la multiplicación; el problema parece ser que cuando hago el módulo por 100011011 (que representa x^8 + x^4 + x^3 + x + 1), no lo hace correctamente. Otra idea sería usar numpy.polynomial pero no es tan intuitivo.
def toBinary(self, n):
return ''.join(str(1 && int(n) >> i) for i in range(8)[::-1])
def add(self, x, y):
'''
"10111001" + "10010100" = "00101101"
'''
if len(x)<8:
self.add('0'+x,y)
elif len(y)<8:
self.add(x,'0'+y)
try:
a = int(x,2); b = int(y,2)
z = int(x)+int(y)
s = ''
for i in str(z):
if int(i)%2 == 0:
s+='0'
else:
s+='1'
except:
return '00000000'
return s
def multiply(self, x, y):
'''
"10111001" * "10010100" = "10110010"
'''
if len(x)<8:
self.multiply('0'+x,y)
elif len(y)<8:
self.multiply(x,'0'+y)
result = '00000000'
while y!= '00000000' :
print(f'x:{x},y:{y},result:{result}')
if int(y[-1]) == 1 :
result = self.add(result ,x)
y = self.add(y, '00000001')
x = self.add(self.toBinary(int(x,2)<<1),'100011011')
y = self.toBinary(int(y,2)>>1)
return result
davy.ai
Para realizar sumas y multiplicaciones en F_{2^8}, necesitamos trabajar en un campo finito. El campo finito con el que estamos trabajando es GF(2^8), lo que significa que el campo tiene 2^8 elementos, y cada elemento puede ser representado por un polinomio binario de grado máximo 7. Podemos sumar y multiplicar elementos en el campo utilizando las operaciones habituales de suma y multiplicación de polinomios, pero con coeficientes módulo 2.
En el código proporcionado, la función de suma parece funcionar correctamente. Sin embargo, parece haber un problema con la función de multiplicación. El problema parece surgir cuando se realiza el módulo por el polinomio 100011011 (que representa x^8 + x^4 + x^3 + x + 1). Este polinomio es el polinomio irreducible que define el campo GF(2^8), y se utiliza como módulo para todas las operaciones aritméticas.
Para solucionar el problema, podemos modificar la función de multiplicación para manejar correctamente la operación de módulo. Un enfoque es utilizar numpy.polynomial, que proporciona funciones convenientes para la aritmética de polinomios en campos finitos. Otro enfoque es modificar el código existente para realizar la operación de módulo correctamente. Una forma de hacer esto es utilizar la operación XOR a nivel de bits en lugar de la suma de enteros al realizar la operación de módulo. También podemos agregar ceros adicionales al final del polinomio antes de realizar la operación de desplazamiento hacia la izquierda para asegurar que el polinomio siempre tenga un grado máximo de 7. El código modificado para la función de multiplicación se muestra a continuación:
En este código modificado, antes de realizar la operación de desplazamiento hacia la izquierda, verificamos si el polinomio tiene un grado mayor que 7, y si es así, lo dividimos en dos polinomios de grado 7 o menor y los sumamos con el polinomio módulo 100011011. Esto garantiza que el polinomio resultante siempre tenga un grado máximo de 7. También agregamos ceros adicionales al final del polinomio para asegurar que siempre tenga 8 bits de longitud.