def equal_degree_splitting(p, d, N=N):
a = rand_polynomial(p.degree - 1, N=N)
if not filter_degree(a):
raise UnluckyStartError
g1 = gcd_polynomial(a, p, N=N)
if not equal_polynomial(polynomial((0, 1), N=N), g1, N=N) and g1.degree > 0:
g1 = mul_polynomial(
g1, polynomial((0, mul_inv(g1.lc(), N=N)), N=N), N=N
)
return g1
b = exp_polynomial_rem(a, int((N ** d - 1) / 2), p, N=N)
b.set_coef(0, b.get_coef(0) - 1)
g2 = extended_euclidean(b, p, N=N)[3]
if (
not (
equal_polynomial(polynomial((0, 1), N=N), g1, N=N)
or equal_polynomial(p, g2, N=N)
)
and g2.degree > 0
):
g2 = mul_polynomial(
g2, polynomial((0, mul_inv(g2.lc(), N=N)), N=N), N=N
)
return g2
else:
raise UnluckyStartError
def iteration(y, num=5):
""" Aguanta hasta 10 iteraciones"""
pol = polynomial([fraction(0), fraction(1)])
for i in range(num):
pol = pol.recursion(y)
leadTerm = pol.coef[-1]
#pol.reduce()
return pol, leadTerm
def __init__(self,fname=None):
if fname:
fitf = open(fname,"r")
self.B = [read_polynomial(fitf) for a in range(3)]
else:
self.B = [polynomial(3) for a in range(3)]
self.ll = self.ur = ()
self.basepath = None
def printRoots(coefficients,roots):
idx = 0
for r in roots:
polyValue = polynomial(coefficients,roots[idx])
print "(%.2f + %.2fj) = %.2f + %.2fj"%(r.real,r.imag,polyValue.real,polyValue.imag), " ",
idx = idx + 1
print " "
def checkFit(self, x):
self.all_fit = 0
for i in self.population:
final = polynomial(x)
sol = getPolynomial(x, i.a, i.b, i.c, i.d, i.e)
tmp = abs(final - sol)
self.all_fit += tmp
i.setFit(tmp)
return self.all_fit / self.LENPOPULATION
def checkFit(self, x):
self.all_fit = 0
for i in self.population:
final = polynomial(x)
sol = getPolynomial(x, i.a, i.b, i.c, i.d, i.e)
tmp = abs(final - sol)
self.all_fit += tmp
i.setFit(tmp)
return self.all_fit / self.LENPOPULATION
def factorise_polynomial_int_finite(p, N=N):
h = polynomial(N=N)
h.set_coef(1, 1)
v = copy.deepcopy(p)
i = 0
# set of factors found
if v.lc() == 1:
U = []
else:
U = [polynomial((0, v.lc()), N=N)]
v = mod_polynomial(v, polynomial((0, v.lc()), N=N), N=N)[0]
v_one = polynomial(N=N)
v_one.set_coef(0, 1)
v_zero = polynomial(N=N)
while not equal_polynomial(v, polynomial((0, 1), N=N), N=N):
i += 1
"""
one distinct degree factorisation step
(removes all factors of degree i)
"""
h = exp_polynomial_rem(h, N, p, N=N)
x = polynomial(N=N)
x.set_coef(1, 1)
g = gcd_polynomial(sub_polynomial(h, x, N=N), v, N=N)
if not equal_polynomial(
g, polynomial((0, 1), N=N), N=N
): # g.degree > 0:
"""
call equal degree factorisation algorithm to separate factors fo degree i
"""
facs = equal_degree_factorisation(g, i, N=N)
"""
determine multiplicites of factors found
"""
for fac in facs:
while equal_polynomial(
mod_polynomial(v, fac, N=N)[1], v_zero, N=N
):
U.append(fac)
v = mod_polynomial(v, fac, N=N)[0]
return U
def diagonal_multiterm_test():
"""Check answer is unchanged, for a heap of gradients"""
for PG in [PG_n(),PG_3He()]:
BC = BCell()
BC.ll,BC.ur = (-20,-3.75,-5.1),(20,3.75,5.1)
BC.B[0] += polynomial(3,{(0,0,0):0.030})
for i in range(3):
BC.B[0] += monomial(basisv(3,i),1e-7)
for j in range(3):
C = tuple([ int(a==i)+int(a==j) for a in range(3)])
BC.B[0] += monomial(C,1e-7)
print PG.name,"1/T2 = %g"%T2i(BC,PG)
def _solvePoly(coefficients, roots, index):
x = roots[index]
denominator = complex(1.0,0.0)
for i in xrange(len(roots)):
if i==index:
continue
denominator *= (x-roots[i])
if abs(denominator-0)< 0.00001:
print "WARNING, denominator==0"
poly = polynomial(coefficients,x)
return x-(poly/denominator)
def getPoly(nDims, maxDegree):
thisRepr = polynomialRepr(nDims,maxDegree)
thisPoly = polynomial(thisRepr,np.random.rand(thisRepr.nMonoms,)-.5)
C = np.random.rand(nDims,nDims)-.5
C = ndot(C,C.T)+np.identity(nDims,nfloat)*.1
Ci = inv(C)
x = np.random.rand(nDims,)
thisPoly.eval(x)
thisPoly.repr.doLinCoordChange(np.copy(thisPoly.coeffs),Ci)
return thisPoly
def equal_degree_factorisation(p, d, N=N):
if p.degree == d:
p = mod_polynomial(p, polynomial((0, p.lc()), N=N), N=N)[0]
return [p]
if p.degree == 0:
return []
while True:
try:
fac = equal_degree_splitting(p, d, N=N)
assert fac.degree == d
except UnluckyStartError:
continue
break
return [
fac,
*equal_degree_factorisation(mod_polynomial(p, fac, N=N)[0], d, N=N),
]
def funcEval(nDims, maxDegree):
thisRepr = polynomialRepr(nDims,maxDegree)
thisPoly = polynomial(thisRepr, np.random.rand(thisRepr.nMonoms,)-.5)
C = np.random.rand(nDims,nDims)-.5
C = ndot(C,C.T)+np.identity(nDims, nfloat)*.1
Ci = inv(C)
#Get the lin coord change
thisPolyTrans = cp(thisPoly)
thisPolyTrans.coeffs = thisPolyTrans.repr.doLinCoordChange(thisPolyTrans.coeffs, Ci)
x = np.random.rand(nDims,)
y = ndot(C,x.reshape((-1,1)))
print(thisPoly.eval(x))
print(thisPolyTrans.eval(y.squeeze()))
def Multifactor_Hensel_Lifting(N, f, a, l, T):
d = int(np.ceil(np.log(l) / np.log(2)))
for j in range(1, d + 1, 1):
N_ = N ** (2 ** j)
a = (2 * a - lc(f) * a * a) % N_
T.value = mul_polynomial(polynomial((0, a), N=N_), f, N=N_)
for node in T.get_walk():
if not node.isleaf():
node.L.value, node.R.value, node.s, node.t = Hensel_step(
node.value,
node.L.value,
node.R.value,
node.s,
node.t,
N=N ** (2 ** (j - 1)),
)
return a, T
def funcTestBase(nDims, maxDeg):
thisRepr = polynomialRepr(nDims, maxDeg)
thisRelax = lasserreRelax(thisRepr)
x = np.random.rand(nDims).astype(nfloat)
print(thisRelax.evalCstr(x))
print("\n\n")
print(thisRepr.listOfMonomialsAsInt)
coeffs = nzeros((thisRepr.nMonoms,),dtype=nfloat)
coeffs[0] = 1.1
coeffs[1] = 2.2
thisPoly = polynomial(thisRepr, coeffs)
thisPolyCstr = lasserreConstraint(thisRelax, thisPoly)
print(thisPolyCstr.evalCstr(x))
#print(thisRepr.__dict__)
return None
def factor(poly, iterations, eps):
if (poly.degree() == 1):
return [fraction(-1) * poly.coef[0] / poly.coef[1]]
if (poly.degree() == 0):
return []
aux = iteration(poly, iterations)[0]
spCase = 0
if (aux.coef[0] == fraction(0)):
spCase = 1
else:
root = extractionLostRoot(poly, aux)
if (abs(poly.evaluate(root)) > eps):
root = fraction(-1) * root
#Is it root?
if (abs(poly.evaluate(root)) > eps):
spCase = 1
if (spCase):
#Complex root or inside M
prevIteration = iteration(poly, iterations - 1)
## Verificar el termino de mayor grado
if (prevIteration[1].decimal() < 1000): ###!!
#And all roots are inside M
print('### Traslacion')
return [factor(poly.move(fraction(3)), iterations, eps)]
else:
#Complex root
difIterations = aux - prevIteration[0]
difIterations.reduce()
division = poly.divisionPolynomial(difIterations)
return factor(difIterations, iterations, eps) + [division[0]]
else:
newPoly = poly.divisionPolynomial(
polynomial([fraction(-1) * root, fraction(1)]))
roots = factor(newPoly[0], iterations, eps)
return roots + [root]
def __init__(self,
repr: polynomialRepr,
solver: str = 'cvxopt',
objective: polynomial = None,
firstVarIsOne: bool = True):
assert solver in ['cvxopt'], 'Solver not supported'
assert (objective is None) or (repr is objective.repr)
self.solver = solver
self.repr = repr
self.constraints = variableStruct(l=variableStruct(nCstr=0,
cstrList=[]),
q=variableStruct(nCstr=0,
cstrList=[]),
s=variableStruct(nCstr=0,
cstrList=[]),
eq=variableStruct(nCstr=0,
cstrList=[]))
self.__objective = polynomial(repr) if objective is None else objective
self.firstVarIsOne = firstVarIsOne
self.isUpdate = False
def poly_from_LF(LF):
"""Re-assemble a linear fitter into a polynomial"""
P = polynomial(LF.terms[0].N)
for (n, t) in enumerate(LF.terms):
P += t * LF.coeffs[n]
return P
else:
others.append((node_c, 1))
for i in range(len(others) - 1, 0, -1):
node_new = factor_tree()
node_new.set_value(others[i - 1][0], others[i][0], N=N)
others = others[:-2]
others.append((node_new, 0))
return others[0][0]
if __name__ == "__main__":
from polynomial_fact_finite import *
p_prob = polynomial()
p_prob.set_coef(0, 21)
p_prob.set_coef(1, 20)
p_prob.set_coef(2, 21)
p_prob.set_coef(3, 9)
p_prob.set_coef(4, 15)
p_prob.set_coef(5, 19)
p_prob.set_coef(6, 8)
p_prob.set_coef(7, 9)
p_prob.set_coef(8, 19)
p_prob.set_coef(9, 1)
p_rand = rand_polynomial(10)
print("random_polynomial: ", p_prob)
print("factorisation: ")
facs = factorise_polynomial_int_finite(p_prob)
for f in facs:
return roots + factor(poly, iterations, eps)
#%%
def printRoots(l):
for i in l:
if (str(type(i)) == "<class 'list'>"):
print('?')
for j in i:
print(j + fraction(4))
print('?')
else:
print(i)
y = polynomial([fraction(314,100),fraction(1)])*\
polynomial([fraction(8125,10000),fraction(1)])*\
polynomial([fraction(431,1000),fraction(1)])*\
polynomial([fraction(-2391,10000),fraction(1)])
print(y)
y.reduce()
print(y)
#print(factor(y,7,0.1)[0])
for i in range(1, 7):
print(iteration(y, i)[0])
"""
p_prob = polynomial()
p_prob.set_coef(0, 21)
p_prob.set_coef(1, 20)
p_prob.set_coef(2, 21)
p_prob.set_coef(3, 9)
p_prob.set_coef(4, 15)
p_prob.set_coef(5, 19)
p_prob.set_coef(6, 8)
p_prob.set_coef(7, 9)
p_prob.set_coef(8, 19)
p_prob.set_coef(9, 4)
p_rand = rand_polynomial(10)
print("random_polynomial: ", p_prob)
"""
p_prob = polynomial()
p_prob.set_coef(0, 2)
p_prob.set_coef(1, 3)
p_prob.set_coef(2, 4)
print("problem_polynomial: ", p_prob)
N = 13
l = 8
a = mul_inv(lc(p_prob), N=N)
p_norm = mul_polynomial(p_prob, polynomial((0, a), N=N), N=N)
print("normalised: ", p_norm)
print("factorisation: ")
facs = factorise_polynomial_int_finite(p_norm, N=N)
for f in facs:
def Hensel_step(f, g, h, s, t, N=N):
assert isinstance(f, polynomial)
assert isinstance(g, polynomial)
assert isinstance(h, polynomial)
assert isinstance(s, polynomial)
assert isinstance(t, polynomial)
assert equal_polynomial(f, mul_polynomial(g, h, N=N), N=N)
"""
print("s: ",s)
print("g: ",g)
print("mul_polynomial(s, g, N=N)",mul_polynomial(s, g, N=N))
print("t: ",t)
print("h: ",h)
print("mul_polynomial(h, t, N=N)", mul_polynomial(h, t, N=N))
print(add_polynomial(
mul_polynomial(s, g, N=N), mul_polynomial(h, t, N=N), N=N
))
"""
assert equal_polynomial(
polynomial((0, 1), N=N),
add_polynomial(
mul_polynomial(s, g, N=N), mul_polynomial(h, t, N=N), N=N
),
N=N,
)
N_ = N ** 2
e = sub_polynomial(f, mul_polynomial(g, h, N=N_), N=N_)
se = mul_polynomial(s, e, N=N_)
q, r = mod_polynomial(se, h, N=N_)
g_ = add_polynomial(
g, mul_polynomial(t, e, N=N_), mul_polynomial(q, g, N=N_), N=N_
)
h_ = add_polynomial(h, r, N=N_)
b = add_polynomial(
mul_polynomial(s, g_, N=N_),
mul_polynomial(t, h_, N=N_),
polynomial((0, -1), N=N_),
N=N_,
)
print("b: ", b)
sb = mul_polynomial(s, b, N=N_)
print("sb: ", sb)
c, d = mod_polynomial(sb, h_, N=N_)
print("c: ", c)
print("d: ", d)
s_ = sub_polynomial(s, d, N=N_)
print("s_: ", s_)
t_ = sub_polynomial(
t,
add_polynomial(
mul_polynomial(t, b, N=N_), mul_polynomial(c, g_, N=N_), N=N_
),
N=N_,
)
print("t_: ", t_)
print("f: ", mod_const(f, N_))
print(
"mul_polynomial(g_, h_, N=N_): ",
mod_const(mul_polynomial(g_, h_, N=N_), N_),
)
print("s_: ", s_)
print("g_: ", g_)
assert equal_polynomial(
mod_polynomial(mul_polynomial(s_, g_, N=N_), g_, N=N_)[0], s_, N=N_
)
print("t_: ", t_)
print("h_: ", h_)
assert equal_polynomial(
mod_polynomial(mul_polynomial(t_, h_, N=N_), h_, N=N_)[0], t_, N=N_
)
assert equal_polynomial(f, mul_polynomial(g_, h_, N=N_), N=N_)
print(
add_polynomial(
mul_polynomial(s_, g_, N=N_), mul_polynomial(h_, t_, N=N_), N=N_
)
)
assert equal_polynomial(
polynomial((0, 1), N=N_),
add_polynomial(
mul_polynomial(s_, g_, N=N_), mul_polynomial(h_, t_, N=N_), N=N_
),
N=N_,
)
return g_, h_, s_, t_
def rand_polynomial(max_degree, N=N):
p = polynomial(N=N)
for i in range(0, max_degree + 1):
p.set_coef(i, randint(0, N))
return p
def funcTestFirstOpt2(relaxOrder=4):
thisRepr = polynomialRepr(2, relaxOrder)
thisRelax = lasserreRelax(thisRepr)
# x^2+y^2<=1 -> 1.-x^2-y^2>=0.
# 1,x,y,x**2,xy,y**2
coeffs = nzeros((thisRepr.nMonoms,), dtype=nfloat)
coeffs[0] = 1.
coeffs[3] = -1.
coeffs[5] = -1.
thisPoly = polynomial(thisRepr, coeffs)
thisPolyCstr = lasserreConstraint(thisRelax, thisPoly)
# objective 1 : convex
# obj = (1+x)^2 + (1+y)^2
coeffs = nzeros((thisRepr.nMonoms,), dtype=nfloat)
coeffs[0] = 1.
coeffs[1] = 1.
obj1 = polynomial(thisRepr, np.copy(coeffs))
coeffs = nzeros((thisRepr.nMonoms,), dtype=nfloat)
coeffs[0] = 1.
coeffs[2] = 1.
obj2 = polynomial(thisRepr, np.copy(coeffs))
obj = obj1**2+obj2**2
thisOpt = convexProg(thisRepr, objective=obj)
thisOpt.addCstr(thisRelax)
sol = thisOpt.solve()
print("Analytic solution is 0. obtained {0}".format(sol['primal objective']))
print("Analytic minimizer is (-1,-1) obtained {0}".format(sol['x_np'][0, 1:3]))
print("relax mat is \n {0}".format(thisRelax.evalCstr(sol['x_np'])))
print("With eigvals \n {0} \n and eigvec \n{1}".format(*eigh(thisRelax.evalCstr(sol['x_np']))))
print("Delta constraints is \n {0}".format(thisRelax.evalCstr(sol['x_np'])-thisRelax.evalCstr(narray([-1., -1.], dtype=nfloat))))
print("With eigvals \n {0} \n and eigvec \n {1}".format(*eigh(thisRelax.evalCstr(sol['x_np'])-thisRelax.evalCstr(narray([-1., -1.], dtype=nfloat)))))
thisOpt.addCstr(thisPolyCstr)
sol = thisOpt.solve()
Osq2 = -1./2.**0.5
print("Analytic solution is 0.17157287525381 obtained {0}".format(sol['primal objective']))
print("Analytic minimizer is (-1/sq2,-1/sq2) obtained {0}".format(sol['x_np'][0, 1:3]))
print("relax mat is \n {0}".format(thisRelax.evalCstr(sol['x_np'])))
print("With eigvals \n {0} \n and eigvec \n{1}".format(*eigh(thisRelax.evalCstr(sol['x_np']))))
print("Delta constraints is \n {0}".format(thisRelax.evalCstr(sol['x_np'])-thisRelax.evalCstr(narray([Osq2, Osq2], dtype=nfloat))))
print("With eigvals \n {0} \n and eigvec \n {1}".format(*eigh(thisRelax.evalCstr(sol['x_np'])-thisRelax.evalCstr(narray([Osq2, Osq2], dtype=nfloat)))))
obj2 = -obj
thisOpt.removeCstr('s', 1)
thisOpt.objective = obj2
sol = thisOpt.solve()
print("Solution should be unbounded")
print(sol)
thisOpt.addCstr(thisPolyCstr)
sol = thisOpt.solve()
Osq2 = 1./2.**0.5
print("Analytic solution is -5.82842712474619 obtained {0}".format(sol['primal objective']))
print("Analytic minimizer is (1/sq2,1/sq2) obtained {0}".format(sol['x_np'][0, 1:3]))
print("relax mat is \n {0}".format(thisRelax.evalCstr(sol['x_np'])))
print("With eigvals \n {0} \n and eigvec \n{1}".format(*eigh(thisRelax.evalCstr(sol['x_np']))))
print("Delta constraints is \n {0}".format(thisRelax.evalCstr(sol['x_np'])-thisRelax.evalCstr(narray([Osq2, Osq2], dtype=nfloat))))
print("With eigvals \n {0} \n and eigvec \n {1}".format(*eigh(thisRelax.evalCstr(sol['x_np'])-thisRelax.evalCstr(narray([Osq2, Osq2], dtype=nfloat)))))
)
break
G.add(f_)
return G
if __name__ == "__main__":
# create logger
logger = logging.getLogger("polynomial_fact_q")
logger.setLevel(logging.DEBUG)
# create console handler and set level to debug
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)
# create formatter
formatter = logging.Formatter("%(name)s - %(levelname)s - %(message)s")
# add formatter to ch
ch.setFormatter(formatter)
# add ch to logger
logger.addHandler(ch)
p = polynomial((1, 3))
p.set_coef(2, 4)
p.set_coef(0, 2)
print("p: ", p)
r = poly_fact_z(p)
print("return: ")
for f in r:
print(f)
def vec_2_poly(v, N=N):
assert isinstance(v, vector)
p_ = polynomial(N=N)
for i in range(v.shape[0]):
p_.set_coef(i, v.val[i])
return p_
def poly_from_LF(LF):
"""Re-assemble a linear fitter into a polynomial"""
P = polynomial(LF.terms[0].N)
for (n,t) in enumerate(LF.terms):
P += t*LF.coeffs[n]
return P
while (poly.degree() > 1 and abs(poly.evaluate(fraction(0))) < 0.0001):
poly.coef = poly.coef[1:]
roots.append(fraction(0))
#we get a polynomial without 0 as root
return roots + factor(poly, iterations, eps)
#%%
def printRoots(l):
for i in l:
if (str(type(i)) == "<class 'list'>"):
print('?')
for j in i:
print(j + fraction(4))
print('?')
else:
print(i)
y = polynomial([fraction(-1, 2), fraction(1, 2), fraction(1, 2), fraction(1)])
y = y.move(fraction(3))
y.reduce()
print(y)
#print(factor(y,7,0.1)[0])
for i in range(1, 7):
print(iteration(y, i)[0])
def poly_fact_z(f):
assert isinstance(f, polynomial)
assert f.degree > 0
output = set()
logger.debug("poly_fact_z called")
# 1
if f.degree == 1:
output.add(f)
return output
b = f.lc()
A = f.max_norm()
n = f.degree
B = ((n + 1) ** 0.5) * (2 ** n) * A
C = ((n + 1) ** (2 * n)) * (A ** (2 * n - 1))
y = np.ceil(2 * (np.log(C) / np.log(2)))
logger.debug("#1 completed")
# 2
prime = gen_primes()
while True:
p = next(prime)
f_bar = mod_const(f, p)
while not (
b % p != 0
and gcd_polynomial(
f_bar, mod_const(deriv_polynomial(f_bar), p), N=p
).degree
== 0
): # equal_polynomial(gcd_polynomial(f_bar,mod_const(deriv_polynomial(f_bar),p),N=p),polynomial((0,1)),N=p))):
p = next(prime)
f_bar = mod_const(f, p)
assert p <= 2 * y * np.log(y)
l = np.ceil(np.log(2 ** (n ** 2) * B ** (2 * n)) / np.log(p))
print("l: ", l)
i = 0
"""
while l >= 2 ** i:
i += 1
l = 2 ** i
print("l: ",l)
"""
logger.debug("#2 completed: possible p={}".format(p))
# 3
b_inv_poly = polynomial((0, mul_inv(b, N=p)), N=p)
f_lc = mul_polynomial(f, b_inv_poly, N=p)
i = 0
while i < 100:
i += 1
h_list = factorise_polynomial_int_finite(f_lc, N=p)
cond = True
for h in h_list:
if h.max_norm() > (p / 2):
cond = False
if not cond:
continue
if cond:
break
b_poly = polynomial((0, b), N=p)
facs = [b_poly] + h_list
assert equal_polynomial(mul_polynomial(*facs, N=p), f, N=p)
logger.debug("#3 completed: factors:")
for h in facs:
logger.debug(h)
# 4
f_tree = make_tree(h_list, N=p)
_, f_tree = Multifactor_Hensel_Lifting(p, f, mul_inv(b, N=p), l, f_tree)
g = [t.value for t in f_tree.get_leaves()]
for gi, hi in zip(g, h_list):
print("p: ", p)
print(gi)
print(hi)
assert equal_polynomial(gi, hi, N=p)
assert gi.max_norm() < p ** l / 2
logger.debug("#4 completed")
# 5
T = set(range(len(h_list)))
G = set()
f_ = copy.deepcopy(f)
logger.debug("#5 completed")
logger.debug("#6 completed")
# 6
while len(T) > 0:
# 7
u = h_list[max(T, key=lambda p: h_list[p].degree)]
d = u.degree
n_ = f_.degree
for i in T:
print(h_list[i])
logger.debug("#7 completed")
for j in range(d + 1, n_ + 1):
# 8
basis_ = basis(N=j)
c = 0
x_poly = polynomial((0, 1), N=p ** (l + 1))
for k in range(0, (j - d)):
new_poly = mul_polynomial(u, x_poly, N=p ** (l + 1))
new_vec = poly_2_vec(new_poly, j)
basis_.set_vec(k, new_vec)
x_poly = mul_polynomial(
x_poly, polynomial((1, 1), N=p ** (l + 1)), N=p ** (l + 1)
)
p_poly = polynomial((0, p ** l), N=p ** (l + 1))
for k in range((j - d), j):
new_vec = poly_2_vec(p_poly, j)
basis_.set_vec(k, new_vec)
p_poly = mul_polynomial(
p_poly, polynomial((1, 1), N=p ** (l + 1)), N=p ** (l + 1)
)
g_vec = basis_reduction(basis_).get_vec(0)
g_ = vec_2_poly(g_vec)
logger.debug(
"#8 completed: {} of {}: g*={}".format((j - d), (n_ - d), g_)
)
# 9
h_ = polynomial((0, b), N=p ** l)
for i in T:
S = set()
if equal_polynomial(
mod_polynomial(g_, h_list[i], N=p)[1], polynomial(N=p), N=p
):
S.add(i)
else:
h_ = mul_polynomial(h_, g[i], N=p ** l)
assert h_.max_norm() < ((p ** l) / 2)
if g_.pp().one_norm() * h_.pp().one_norm() <= B:
for i in S:
print("S: ", h_list[i])
T = T - S
G.add(g_.pp())
f_ = h_.pp()
b = f_.lc()
logger.debug(
"#9 completed: {} of {}: g*={}".format(
(j - d), (n_ - d), g_
)
)
break
G.add(f_)
return G
"""
determine multiplicites of factors found
"""
for fac in facs:
while equal_polynomial(
mod_polynomial(v, fac, N=N)[1], v_zero, N=N
):
U.append(fac)
v = mod_polynomial(v, fac, N=N)[0]
return U
if __name__ == "__main__":
p_prob = polynomial(N=29)
p_prob.set_coef(0, 15)
p_prob.set_coef(1, 8)
p_prob.set_coef(2, 1)
p3 = polynomial()
p3.set_coef(0, 2)
p3.set_coef(1, 3)
p3.set_coef(2, 1)
p4 = polynomial()
p4.set_coef(0, 1)
p4.set_coef(1, 3)
p4.set_coef(2, 3)
p4.set_coef(3, 1)
# print("p3:", p3)
p_rand = rand_polynomial(6)
print("random_polynomial: ", p_prob)
def Hensel_step(f, g, h, s, t, N=N):
assert isinstance(f, polynomial)
assert isinstance(g, polynomial)
assert isinstance(h, polynomial)
assert isinstance(s, polynomial)
assert isinstance(t, polynomial)
assert equal_polynomial(f, mul_polynomial(g, h, N=N), N=N)
"""
print("s: ",s)
print("g: ",g)
print("mul_polynomial(s, g, N=N)",mul_polynomial(s, g, N=N))
print("t: ",t)
print("h: ",h)
print("mul_polynomial(h, t, N=N)", mul_polynomial(h, t, N=N))
print(add_polynomial(
mul_polynomial(s, g, N=N), mul_polynomial(h, t, N=N), N=N
))
"""
assert equal_polynomial(
polynomial((0, 1), N=N),
add_polynomial(mul_polynomial(s, g, N=N),
mul_polynomial(h, t, N=N),
N=N),
N=N,
)
N_ = N**2
e = sub_polynomial(f, mul_polynomial(g, h, N=N_), N=N_)
se = mul_polynomial(s, e, N=N_)
q, r = mod_polynomial(se, h, N=N_)
g_ = add_polynomial(g,
mul_polynomial(t, e, N=N_),
mul_polynomial(q, g, N=N_),
N=N_)
h_ = add_polynomial(h, r, N=N_)
b = add_polynomial(
mul_polynomial(s, g_, N=N_),
mul_polynomial(t, h_, N=N_),
polynomial((0, -1), N=N_),
N=N_,
)
sb = mul_polynomial(s, b, N=N_)
c, d = mod_polynomial(sb, h_, N=N_)
s_ = sub_polynomial(s, d, N=N_)
t_ = sub_polynomial(
t,
add_polynomial(mul_polynomial(t, b, N=N_),
mul_polynomial(c, g_, N=N_),
N=N_),
N=N_,
)
assert equal_polynomial(f, mul_polynomial(g_, h_, N=N_), N=N_)
assert equal_polynomial(
polynomial((0, 1), N=N_),
add_polynomial(mul_polynomial(s_, g_, N=N_),
mul_polynomial(h_, t_, N=N_),
N=N_),
N=N_,
)
return g_, h_, s_, t_
