Question

我想在有限域的点上使用python插值多项式，并得到该字段中具有系数的多项式。目前我正在尝试使用SymPy并专门插值（来自sympy.polys.polyfuncs），但我不知道如何强制插值在特定的gf中发生。如果没有，可以用另一个模块完成吗？

编辑：我对Python实现/库感兴趣。

Answer 1

SymPy的interpolating_poly不支持有限域上的多项式。但是在SymPy的引擎盖下有足够的细节来组合有限域的类，并以残酷的直接方式找到Lagrange polynomial的系数。

像往常一样，有限域GF（p ⁿ）的元素是小于n的represented by polynomials，系数在GF（p）中。乘法以模n的简化多项式为模，在场构造时选择。使用扩展的欧几里德算法进行反演。

多项式由系数列表表示，最高度先表示。例如，GF（3 ²）的元素是：

[], [1], [2], [1, 0], [1, 1], [1, 2], [2, 0], [2, 1], [2, 2]

空列表代表0。

GF类，有限域

将算法实现为方法add，sub，mul，inv（乘法逆）。为了便于测试，插值包括eval_poly，其在GF（p ⁿ）处用GF（p ⁿ）中的系数评估给定多项式。

请注意，构造函数用作G（3,2），而不是G（9）， - 素数和它的幂是单独提供的。

import itertools
from functools import reduce
from sympy import symbols, Dummy
from sympy.polys.domains import ZZ
from sympy.polys.galoistools import (gf_irreducible_p, gf_add, \
                                     gf_sub, gf_mul, gf_rem, gf_gcdex)
from sympy.ntheory.primetest import isprime

class GF():
    def __init__(self, p, n=1):
        p, n = int(p), int(n)
        if not isprime(p):
            raise ValueError("p must be a prime number, not %s" % p)
        if n <= 0:
            raise ValueError("n must be a positive integer, not %s" % n)
        self.p = p
        self.n = n
        if n == 1:
            self.reducing = [1, 0]
        else:
            for c in itertools.product(range(p), repeat=n):
              poly = (1, *c)
              if gf_irreducible_p(poly, p, ZZ):
                  self.reducing = poly
                  break

    def add(self, x, y):
        return gf_add(x, y, self.p, ZZ)

    def sub(self, x, y):
        return gf_sub(x, y, self.p, ZZ)

    def mul(self, x, y):
        return gf_rem(gf_mul(x, y, self.p, ZZ), self.reducing, self.p, ZZ)

    def inv(self, x):
        s, t, h = gf_gcdex(x, self.reducing, self.p, ZZ)
        return s

    def eval_poly(self, poly, point):
        val = []
        for c in poly:
            val = self.mul(val, point)
            val = self.add(val, c)
        return val

类PolyRing，字段上的多项式

这个更简单：它实现了多项式的加法，减法和乘法，参考了对系数进行操作的地面场。有很多列表反转[::-1]，因为SymPy的惯例是列出以最高权力开始的单项式。

class PolyRing():
    def __init__(self, field):
        self.K = field

    def add(self, p, q):
        s = [self.K.add(x, y) for x, y in \
             itertools.zip_longest(p[::-1], q[::-1], fillvalue=[])]
        return s[::-1]       

    def sub(self, p, q):
        s = [self.K.sub(x, y) for x, y in \
             itertools.zip_longest(p[::-1], q[::-1], fillvalue=[])]
        return s[::-1]     

    def mul(self, p, q):
        if len(p) < len(q):
            p, q = q, p
        s = [[]]
        for j, c in enumerate(q):
            s = self.add(s, [self.K.mul(b, c) for b in p] + \
                         [[]] * (len(q) - j - 1))
        return s

插值多项式的构造。

Lagrange polynomial是为列表X中给定的x值和数组Y中相应的y值构造的。它是基多项式的线性组合，每个X的元素一个。每个基多项式由下式获得：乘以(x-x_k)个多项式，表示为[[1], K.sub([], x_k)]。分母是标量，因此计算起来更容易。

def interp_poly(X, Y, K):
    R = PolyRing(K)
    poly = [[]]
    for j, y in enumerate(Y):
        Xe = X[:j] + X[j+1:]
        numer = reduce(lambda p, q: R.mul(p, q), ([[1], K.sub([], x)] for x in Xe))
        denom = reduce(lambda x, y: K.mul(x, y), (K.sub(X[j], x) for x in Xe))
        poly = R.add(poly, R.mul(numer, [K.mul(y, K.inv(denom))]))
    return poly

用法示例：

K = GF(2, 4) 
X = [[], [1], [1, 0, 1]]                # 0, 1,   a^2 + 1
Y = [[1, 0], [1, 0, 0], [1, 0, 0, 0]]   # a, a^2, a^3
intpoly = interp_poly(X, Y, K)
pprint(intpoly)
pprint([K.eval_poly(intpoly, x) for x in X])  # same as Y

漂亮的打印只是为了避免输出上的某些与类型相关的装饰。多项式显示为[[1], [1, 1, 1], [1, 0]]。为了提高可读性，我添加了一个函数，以更熟悉的形式将其转换为符号a是有限域的生成器，x是多项式中的变量。

def readable(poly, a, x):
    return Poly(sum((sum((c*a**j for j, c in enumerate(coef[::-1])), S.Zero) * x**k \
               for k, coef in enumerate(poly[::-1])), S.Zero), x)

所以我们可以做到

a, x = symbols('a x')
print(readable(intpoly, a, x))

并获取

Poly(x**2 + (a**2 + a + 1)*x + a, x, domain='ZZ[a]')

这个代数对象不是我们领域的多项式，这只是为了可读输出。

鼠尾草

作为替代方案，或者只是另一项安全检查，可以使用Sage的lagrange_polynomial获取相同的数据。

field = GF(16, 'a')
a = field.gen()
R = PolynomialRing(field, "x")
points = [(0, a), (1, a^2), (a^2+1, a^3)]
R.lagrange_polynomial(points)

输出：x^2 + (a^2 + a + 1)*x + a

在有限域

1 个答案:

GF类，有限域

类PolyRing，字段上的多项式

插值多项式的构造。

用法示例：

鼠尾草