Campos Finitos

Un campo finito es un conjunto de números donde puedes realizar operaciones como suma, resta, multiplicación y división (excepto por 0), y siempre obtendrás un resultado dentro del mismo conjunto.

• Ejemplo simple: Si p=7p = 7p=7, los elementos son {0,1,2,3,4,5,6}.
• Todas las operaciones están definidas módulo ppp:
  • $$(3+5)mod  7=1(3 + 5) \mod 7 = 1(3+5)mod7=1$$
  • $$(4×6)mod  7=3(4 \times 6) \mod 7 = 3(4×6)mod7=3$$

Bitcoin usa campos finitos para la aritmética subyacente en las curvas elípticas. Estos campos aseguran que los números siempre permanezcan dentro de un rango predecible, mejorando la eficiencia y evitando desbordamientos.

Análisis del Código

a. Constructor:

def __init__(self, num, prime):
    if num >= prime or num < 0:
        error = 'Num {} not in field range 0 to {}'.format(num, prime - 1)
        raise ValueError(error)
    self.num = num
    self.prime = prime

• Valida que el número (num) esté en el rango válido [0,p−1][0, p-1], donde pp es primo.
• Esto asegura que todos los elementos sean válidos dentro del campo Fp\mathbb{F}_p.

b. Operaciones básicas:

1. Suma (__add__):

   num = (self.num + other.num) % self.prime
   return self.__class__(num, self.prime)
   

   • Suma dos elementos del campo y toma el módulo pp para asegurarse de que el resultado esté en el rango válido.

2. Resta (__sub__):

   num = (self.num - other.num) % self.prime
   return self.__class__(num, self.prime)
   

   • Similar a la suma, pero resta los valores antes de tomar el módulo pp.

3. Multiplicación (__mul__):

   num = (self.num * other.num) % self.prime
   return self.__class__(num, self.prime)
   

   • Multiplica los elementos y toma el módulo pp.

4. División (__truediv__):

   num = (self.num * pow(other.num, self.prime - 2, self.prime)) % self.prime
   return self.__class__(num, self.prime)
   

   • Usa el Teorema Pequeño de Fermat, que establece que: ap−1≡1 (mod p)para a≠0a^{p-1} \equiv 1 \ (\text{mod } p) \quad \text{para } a \neq 0 De aquí deduce: a−1≡ap−2 (mod p)a^{-1} \equiv a^{p-2} \ (\text{mod } p) Esto permite calcular la inversa modular, necesaria para la división.

5. Exponenciación (__pow__):

   num = pow(self.num, n, self.prime)
   return self.__class__(num, self.prime)
   

   • Calcula potencias de un elemento en el campo usando exponenciación modular.

Supongamos que queremos sumar 2+52 + 5 en el campo finito (\\mathbb{F}_7\):

a = FieldElement(2, 7)
b = FieldElement(5, 7)
print(a + b)  # FieldElement_7(0)

El resultado es 0, porque (2+5) mod 7 = 0