def testDegree(self):
f = univar.BasicPolynomial({1: 2, 4: -1})
self.assertEqual(4, termorder.ascending_order.degree(f))
g = univar.SortedPolynomial([(1, 2), (4, -1)])
self.assertEqual(4, termorder.ascending_order.degree(g))
zero = univar.BasicPolynomial(())
self.assertTrue(termorder.ascending_order.degree(zero) < 0)
def testScalarMul(self):
b = univar.BasicPolynomial([(0, 1), (1, 4), (2, 10), (3, 12)])
s = univar.SortedPolynomial([(0, 1), (1, 4), (2, 10), (3, 12)])
d = univar.BasicPolynomial([(0, 2), (1, 8), (2, 20), (3, 24)])
self.assertEqual(d, b * 2)
self.assertEqual(d, 2 * b)
self.assertEqual(d, s * 2)
self.assertEqual(d, 2 * s)
def testFormat(self):
"""
format works.
"""
f = univar.BasicPolynomial({0: 4.3})
asc_str = "4.3"
self.assertEqual(asc_str, termorder.ascending_order.format(f))
f = univar.BasicPolynomial({1: 3, 4: 2})
asc_str = "3 * X + 2 * X ** 4"
desc_str = "2 * X ** 4 + 3 * X"
self.assertEqual(asc_str, termorder.ascending_order.format(f))
self.assertEqual(desc_str,
termorder.ascending_order.format(f, reverse=True))
f = univar.BasicPolynomial({1: 3, 4: -2})
asc_str = "3 * X - 2 * X ** 4"
self.assertEqual(asc_str, termorder.ascending_order.format(f))
f = univar.BasicPolynomial({1: 1, 4: 2})
asc_str = "X + 2 * X ** 4"
self.assertEqual(asc_str, termorder.ascending_order.format(f))
f = univar.BasicPolynomial({1: 2, 4: -1})
asc_str = "2 * Y - Y ** 4"
self.assertEqual(asc_str, termorder.ascending_order.format(f, "Y"))
def embedding(f_q1, f_q2):
"""
Return embedding homomorphism function from f_q1 to f_q2,
where q1 = p ** k1, q2 = p ** k2 and k1 divides k2.
"""
if card(f_q1) == card(f_q2):
return fqiso(f_q1, f_q2)
# search multiplicative generators of both fields and relate them.
# 0. initialize basic variables
p = f_q2.getCharacteristic()
q1, q2 = card(f_q1), card(f_q2)
q1_mult_order, q2_mult_order = q1 - 1, q2 - 1
# 1. find a multiplicative generator of f_q2
for i in bigrange.range(p, q2):
f_q2_gen = f_q2.createElement(i)
if f_q2.order(f_q2_gen) == q2_mult_order:
break
f_q2_subgen = f_q2_gen**((q2 - 1) // (q1 - 1))
# 2.1 minimal polynomial of g = f_q2_gen ** ((q2 - 1) // (q1 - 1))
# minpoly = (X - g)(X - g**p)...(X - g**(p**(k1 - 1)))
q, gpow = 1, f_q2_subgen
linear_factors = []
while q < q2:
linear_factors.append(univar.BasicPolynomial({0: gpow, 1: f_q2.one}))
# finally, raise power (Frobenius map).
q *= p
gpow **= p
minpoly = arith1.product(linear_factors)
# 2.2 minpoly has f_q2 coefficints but they are indeed f_p elements
minpoly = univar.BasicPolynomial([(d, c.rep[0]) for (d, c) in minpoly])
# 3. find a multiplicative generator of f_q1
for i in bigrange.range(p, q1):
f_q1_gen = f_q1.createElement(i)
if f_q1.order(f_q1_gen) == q1_mult_order:
break
# 4. find f_q1_gen ** c of a root of minpoly and let it f_q1_gen
for c in bigrange.range(1, q1):
if gcd.coprime(c, q1_mult_order):
if not minpoly(f_q1_gen**c):
break
f_q1_gen = f_q1_gen**c
# 5. solve DLP:
# x_1 = f_q1_gen ** t
# (Here uses "brute force" method)
x_1 = f_q1.createElement(p)
gpow = f_q1_gen
for i in bigrange.range(1, q):
if gpow == x_1:
image_of_x_1 = f_q2_subgen**i
break
gpow *= f_q1_gen
# finally, define a function
def f_q1_to_f_q2_homo(f_q1_elem):
"""
Return the image of the isomorphism of the given element.
"""
if not f_q1_elem:
return f_q2.zero
if f_q1_elem.rep.degree() == 0:
# F_p elements
return f_q2.createElement(f_q1_elem.rep)
return f_q1_elem.rep(image_of_x_1)
return f_q1_to_f_q2_homo
def testGcd(self):
one = univar.BasicPolynomial({0: rational.Rational(1)})
self.assertEqual(one, self.h.gcd(self.i))
def testAdd(self):
h = univar.BasicPolynomial({0: 1, 1: 1, 3: 2, 4: 3})
self.assertEqual(h, self.f + self.g)
self.assertEqual(h, self.g + self.f)
def setUp(self):
self.f = univar.BasicPolynomial({0: 1, 1: 2, 4: 3})
self.g = univar.BasicPolynomial({1: -1, 3: 2})
def testDifferentiate(self):
h = univar.BasicPolynomial({0: -1, 2: 6})
self.assertEqual(h, self.g.differentiate())
def testPow(self):
h1 = univar.BasicPolynomial({0: 1, 1: 4, 2: 4, 4: 6, 5: 12, 8: 9})
h2 = univar.BasicPolynomial({3: -1, 5: 6, 7: -12, 9: 8})
self.assertEqual(h1, self.f**2)
self.assertEqual(h2, self.g**3)
def testMul(self):
h = univar.BasicPolynomial({1: -1, 2: -2, 3: 2, 4: 4, 5: -3, 7: 6})
self.assertEqual(h, self.f * self.g)
self.assertEqual(h, self.g * self.f)
self.assertEqual(-self.g, self.g * (-1))
self.assertEqual(-self.g, (-1) * self.g)
def testNeg(self):
h = univar.BasicPolynomial({0: -1, 1: -2, 4: -3})
self.assertEqual(h, -self.f)
def setUp(self):
self.b = univar.BasicPolynomial({0: 1, 1: 4, 2: 4, 4: 6, 5: 12, 8: 9})
self.s = univar.SortedPolynomial({0: 1, 1: 4, 2: 4, 4: 6, 5: 12, 8: 9})
def testLeadingTerm(self):
f = univar.BasicPolynomial({1: 2, 4: -1})
self.assertEqual((4, -1), termorder.ascending_order.leading_term(f))
g = univar.SortedPolynomial([(1, 2), (4, -1)])
self.assertEqual((4, -1), termorder.ascending_order.leading_term(g))
def testLeadingCoefficient(self):
f = univar.BasicPolynomial({1: 2, 4: -1})
self.assertEqual(-1, termorder.ascending_order.leading_coefficient(f))
g = univar.SortedPolynomial([(1, 2), (4, -1)])
self.assertEqual(-1, termorder.ascending_order.leading_coefficient(g))