Question

我试图实现一个可以在Galois Field（3）上工作的高斯算法。我已经在GF（2）上成功实现了算法，但GF（3）似乎有点棘手。我的主要问题是：当我选择的枢轴线的值是2（pl = 2）时，如何消除列中的2？我的第一个想法是将pl / 2添加到2，但在GF（3）中，我不确定2/2 = 1。

Answer 1

2/2 == 1总是，因为1是乘法的中性元素。

在有限的领域中，不确定2是2的唯一除数导致1。

通常，只需使用乘法而不是除法来达到1;更容易！

Answer 2

要消去域a = 2中的主元GF(3)，需要在伽罗瓦域中找到2的乘法逆，使得a * a_inv = 1中的GF(3)。因此，要除以 a，您将乘以 a_inv（mod 3）。恰好是 a_inv = 2，但不是因为 2/2 = 1（这是不正确的）。例如，在 GF(5) 中，2 的倒数是 3，而不是 2。

在素数域 GF(p) 中查找元素的逆的方法是使用 Extended Euclidean Algorithm。该算法找到整数 d, s, t，使得 d = a*s + b*t = gcd(a, b)。对于素数域 GF(p) 来查找元素 a 的逆，您计算 1 = a*s + p*t = gcd(a, p) 和 a_inv = s。 GCD 始终为 1，因为 p 是质数。

我编写了一个 Python 包 galois，它在 Galois 字段上扩展了 NumPy 数组。它还包括用于计算扩展欧几里得算法的函数等。以下是使用 galois 的示例。

在 GF(3) 中手动找到 2 的倒数。

In [1]: import galois                                                                                                                                                                          

In [2]: a, p = 2, 3                                                                                                                                                                            

In [3]: d, s, t = galois.egcd(a, p); d, s, t                                                                                                                                                   
Out[3]: (1, -1, 1)

In [4]: a_inv = s % p; a_inv                                                                                                                                                                   
Out[4]: 2

In [5]: a * a_inv % p                                                                                                                                                                          
Out[5]: 1

在 GF(5) 中手动找到 2 的倒数。

In [6]: a, p = 2, 5                                                                                                                                                                            

In [7]: d, s, t = galois.egcd(a, p); d, s, t                                                                                                                                                   
Out[7]: (1, -2, 1)

In [8]: a_inv = s % p; a_inv                                                                                                                                                                   
Out[8]: 3

In [9]: a * a_inv % p                                                                                                                                                                          
Out[9]: 1

或者，您可以使用 galois 创建字段 GF(5)，然后直接计算逆函数，如库所希望的那样。

In [10]: GF = galois.GF(5)                                                                                                                                                                     

In [11]: GF(2)**-1                                                                                                                                                                             
Out[11]: GF(3, order=5)

还支持线性代数，包括您提到的行缩减（高斯消元）和矩阵求逆。

In [19]: import numpy as np                                                                                                                                                                    

In [20]: GF = galois.GF(3)                                                                                                                                                                     

In [21]: A = GF.Random((4,4)); A                                                                                                                                                               
Out[21]: 
GF([[2, 2, 2, 2],
    [0, 2, 1, 1],
    [0, 1, 0, 1],
    [2, 1, 2, 0]], order=3)

In [22]: A.row_reduce()                                                                                                                                                                        
Out[22]: 
GF([[1, 0, 0, 0],
    [0, 1, 0, 0],
    [0, 0, 1, 0],
    [0, 0, 0, 1]], order=3)

In [23]: A_inv = np.linalg.inv(A); A_inv                                                                                                                                                       
Out[23]: 
GF([[1, 2, 2, 1],
    [2, 0, 2, 1],
    [1, 1, 0, 2],
    [1, 0, 2, 2]], order=3)

In [24]: A @ A_inv                                                                                                                                                                             
Out[24]: 
GF([[1, 0, 0, 0],
    [0, 1, 0, 0],
    [0, 0, 1, 0],
    [0, 0, 0, 1]], order=3)

GF上的高斯消元（3）

2 个答案: