Numpy 矩阵求逆与对象

Question

I'm using the gf256 library to do galois field math, and I have it in a numpy matrix. Though when calling np.linalg.inv() with it, it throws an error.

That's the summary, here's the details:

import numpy as np
from gf256 import GF256 as gf
npgf = np.vectorize(gf)

arr = np.identity(4, np.uint8) * 10
gfarr = npgf(arr)

After all this, gfarr looks like this

array([[GF256(0b00001010), GF256(0b00000000), GF256(0b00000000),
        GF256(0b00000000)],
       [GF256(0b00000000), GF256(0b00001010), GF256(0b00000000),
        GF256(0b00000000)],
       [GF256(0b00000000), GF256(0b00000000), GF256(0b00001010),
        GF256(0b00000000)],
       [GF256(0b00000000), GF256(0b00000000), GF256(0b00000000),
        GF256(0b00001010)]], dtype=object)

And np.linalg.inv(gfarr) throws this error

Traceback (most recent call last):
  File "<pyshell#152>", line 1, in <module>
    np.linalg.inv(gfarr)
  File "[python3.6]\lib\site-packages\numpy\linalg\linalg.py", line 528, in inv
    ainv = _umath_linalg.inv(a, signature=signature, extobj=extobj)
TypeError: No loop matching the specified signature and casting
was found for ufunc inv

The matrix is definitely invertable, and the GF256 class supports all the usual operators. Is it possible to make this work with numpy?

Answer 1

np.linalg.inv will invoke a BLAS/LAPACK implementation of matrix inversion using floats, but you need to use Galois field arithmetic in the matrix inversion process. To do this, the NumPy array will need to intercept or override the call to np.linalg.inv in __array_function__() . The matrix inversion of A can be accomplished using Gaussian elimination on [A | I] [A | I] over the Galois field, which yields [I | A^-1] [I | A^-1] .

I had a similar use case, so I created a Python package called galois that extends NumPy arrays over Galois fields. It replaces the NumPy ufuncs with JIT compiled ufuncs using Numba. This means the array arithmetic is as fast, or nearly as fast, as normal NumPy arithmetic. See this performance comparison .

It also supports linear algebra and overrides the relevant np.linalg functions. So the matrix inversion you're looking for works out of the box. Here's an example using your matrix.

In [1]: import numpy as np                                                                                                                                                                     

In [2]: import galois                                                                                                                                                                          

In [3]: GF = galois.GF(2**8)                                                                                                                                                                   

In [4]: print(GF.properties)                                                                                                                                                                   
GF(2^8):
  characteristic: 2
  degree: 8
  order: 256
  irreducible_poly: x^8 + x^4 + x^3 + x^2 + 1
  is_primitive_poly: True
  primitive_element: x

In [5]: A = GF.Identity(4) * GF(10); A                                                                                                                                                         
Out[5]: 
GF([[10,  0,  0,  0],
    [ 0, 10,  0,  0],
    [ 0,  0, 10,  0],
    [ 0,  0,  0, 10]], order=2^8)

In [6]: A_inv = np.linalg.inv(A); A_inv                                                                                                                                                        
Out[6]: 
GF([[221,   0,   0,   0],
    [  0, 221,   0,   0],
    [  0,   0, 221,   0],
    [  0,   0,   0, 221]], order=2^8)

In [7]: A @ A_inv                                                                                                                                                                              
Out[7]: 
GF([[1, 0, 0, 0],
    [0, 1, 0, 0],
    [0, 0, 1, 0],
    [0, 0, 0, 1]], order=2^8)