/* jac^floor(N/pk) mod (N, polcyclo(pk)), flexible window */
static GEN
_powpolmod(Cache *C, GEN jac, Red *R, GEN (*_sqr)(GEN, Red *))
{
const GEN taba = C->aall;
const GEN tabt = C->tall;
const long efin = lg(taba)-1, lv = R->lv;
GEN L, res = jac, pol2 = _sqr(res, R);
long f;
pari_sp av0 = avma, av;
L = cgetg(lv+1, t_VEC); gel(L,1) = res;
for (f=2; f<=lv; f++) gel(L,f) = _mul(gel(L,f-1), pol2, R);
av = avma;
for (f = efin; f >= 1; f--)
{
GEN t = gel(L, taba[f]);
long tf = tabt[f];
res = (f==efin)? t: _mul(t, res, R);
while (tf--) {
res = _sqr(res, R);
if (gc_needed(av,1)) {
res = gerepilecopy(av, res);
if(DEBUGMEM>1) pari_warn(warnmem,"powpolmod: f = %ld",f);
}
}
}
return gerepilecopy(av0, res);
}
static GEN
subfieldsall(GEN nf)
{
pari_sp av = avma;
long N, ld, i, v0;
GEN G, pol, dg, LSB, NLSB;
poldata PD;
primedata S;
blockdata B;
/* much easier if nf is Galois (WSS) */
G = galoisconj4(nf, NULL, 1);
if (typ(G) != t_INT)
{
GEN L, S, p;
long l;
pol = get_nfpol(nf, &nf);
L = lift_intern( galoissubfields(G, 0, varn(pol)) );
l = lg(L);
S = cgetg(l, t_VECSMALL);
for (i=1; i<l; i++) S[i] = lg(gmael(L,i,1));
p = vecsmall_indexsort(S);
return gerepilecopy(av, vecpermute(L, p));
}
subfields_poldata(nf, &PD);
pol = PD.pol;
v0 = varn(pol); N = degpol(pol);
dg = divisors(utoipos(N)); ld = lg(dg)-1;
if (DEBUGLEVEL) fprintferr("\n***** Entering subfields\n\npol = %Z\n",pol);
LSB = _subfield(pol, pol_x[0]);
if (ld > 2)
{
B.PD = &PD;
B.S = &S;
B.N = N;
choose_prime(&S, PD.pol, PD.dis);
for (i=2; i<ld; i++)
{
B.size = itos(gel(dg,i));
B.d = N / B.size;
NLSB = subfields_of_given_degree(&B);
if (NLSB) { LSB = concat(LSB, NLSB); gunclone(NLSB); }
}
(void)delete_var(); /* from choose_prime */
}
LSB = shallowconcat(LSB, _subfield(pol_x[0], pol));
if (DEBUGLEVEL) fprintferr("\n***** Leaving subfields\n\n");
return fix_var(gerepilecopy(av, LSB), v0);
}
GEN
subfields(GEN nf, GEN d0)
{
pari_sp av = avma;
long N, v0, d = itos(d0);
GEN LSB, pol, G;
poldata PD;
primedata S;
blockdata B;
pol = get_nfpol(nf, &nf); /* in order to treat trivial cases */
v0 = varn(pol); N = degpol(pol);
if (d == N) return gerepilecopy(av, _subfield(pol, pol_x[v0]));
if (d == 1) return gerepilecopy(av, _subfield(pol_x[v0], pol));
if (d < 1 || d > N || N % d) return cgetg(1,t_VEC);
/* much easier if nf is Galois (WSS) */
G = galoisconj4(nf? nf: pol, NULL, 1);
if (typ(G) != t_INT)
{ /* Bingo */
GEN L = galoissubgroups(G), F;
long k,i, l = lg(L), o = N/d;
F = cgetg(l, t_VEC);
k = 1;
for (i=1; i<l; i++)
{
GEN H = gel(L,i);
if (group_order(H) == o)
gel(F,k++) = lift_intern(galoisfixedfield(G, gel(H,1), 0, v0));
}
setlg(F, k);
return gerepilecopy(av, F);
}
subfields_poldata(nf? nf: pol, &PD);
B.PD = &PD;
B.S = &S;
B.N = N;
B.d = d;
B.size = N/d;
choose_prime(&S, PD.pol, PD.dis);
LSB = subfields_of_given_degree(&B);
(void)delete_var(); /* from choose_prime */
avma = av;
if (!LSB) return cgetg(1, t_VEC);
G = gcopy(LSB); gunclone(LSB);
return fix_var(G, v0);
}
/* return P(X + c) using destructive Horner, optimize for c = 1,-1 */
GEN
translate_pol(GEN P, GEN c)
{
pari_sp av = avma, lim;
GEN Q, *R;
long i, k, n;
if (!signe(P) || gcmp0(c)) return gcopy(P);
Q = shallowcopy(P);
R = (GEN*)(Q+2); n = degpol(P);
lim = stack_lim(av, 2);
if (gcmp1(c))
{
for (i=1; i<=n; i++)
{
for (k=n-i; k<n; k++) R[k] = gadd(R[k], R[k+1]);
if (low_stack(lim, stack_lim(av,2)))
{
if(DEBUGMEM>1) pari_warn(warnmem,"TR_POL(1), i = %ld/%ld", i,n);
Q = gerepilecopy(av, Q); R = (GEN*)Q+2;
}
}
}
else if (gcmp_1(c))
{
for (i=1; i<=n; i++)
{
for (k=n-i; k<n; k++) R[k] = gsub(R[k], R[k+1]);
if (low_stack(lim, stack_lim(av,2)))
{
if(DEBUGMEM>1) pari_warn(warnmem,"TR_POL(-1), i = %ld/%ld", i,n);
Q = gerepilecopy(av, Q); R = (GEN*)Q+2;
}
}
}
else
{
for (i=1; i<=n; i++)
{
for (k=n-i; k<n; k++) R[k] = gadd(R[k], gmul(c, R[k+1]));
if (low_stack(lim, stack_lim(av,2)))
{
if(DEBUGMEM>1) pari_warn(warnmem,"TR_POL, i = %ld/%ld", i,n);
Q = gerepilecopy(av, Q); R = (GEN*)Q+2;
}
}
}
return gerepilecopy(av, Q);
}
GEN
nffactormod(GEN nf, GEN x, GEN pr)
{
long j, l, vx = varn(x), vn;
pari_sp av = avma;
GEN F, E, rep, xrd, modpr, T, p;
nf = checknf(nf);
vn = varn(nf[1]);
if (typ(x)!=t_POL) pari_err(typeer,"nffactormod");
if (varncmp(vx,vn) >= 0)
pari_err(talker,"polynomial variable must have highest priority in nffactormod");
modpr = nf_to_ff_init(nf, &pr, &T, &p);
xrd = modprX(x, nf, modpr);
rep = FqX_factor(xrd,T,p);
settyp(rep, t_MAT);
F = gel(rep,1); l = lg(F);
E = gel(rep,2); settyp(E, t_COL);
for (j = 1; j < l; j++) {
gel(F,j) = modprX_lift(gel(F,j), modpr);
gel(E,j) = stoi(E[j]);
}
return gerepilecopy(av, rep);
}
/* Finds a random non-singular point on E */
GEN
random_F2xqE(GEN a, GEN a6, GEN T)
{
pari_sp ltop = avma;
GEN x, y, rhs, u;
do
{
avma= ltop;
x = random_F2x(F2x_degree(T),T[1]);
if (typ(a) == t_VECSMALL)
{
GEN a2 = a, x2;
if (!lgpol(x))
{ avma=ltop; retmkvec2(pol0_Flx(T[1]), F2xq_sqrt(a6,T)); }
u = x; x2 = F2xq_sqr(x, T);
rhs = F2x_add(F2xq_mul(x2,F2x_add(x,a2),T),a6);
rhs = F2xq_div(rhs,x2,T);
}
else
{
GEN a3 = gel(a,1), a4 = gel(a,2), a3i = gel(a,3), u2i;
u = a3; u2i = F2xq_sqr(a3i,T);
rhs = F2x_add(F2xq_mul(x,F2x_add(F2xq_sqr(x,T),a4),T),a6);
rhs = F2xq_mul(rhs,u2i,T);
}
} while (F2xq_trace(rhs,T));
y = F2xq_mul(F2xq_Artin_Schreier(rhs, T), u, T);
return gerepilecopy(ltop, mkvec2(x, y));
}
static GEN
nf_chk_factors(nfcmbf_t *T, GEN P, GEN M_L, GEN famod, GEN pk)
{
GEN nf = T->nf, bound = T->bound;
GEN nfT = gel(nf,1);
long i, r;
GEN pol = P, list, piv, y;
GEN C2ltpol, C = T->L->topowden, Tpk = T->L->Tpk;
GEN lc = absi(leading_term(pol)), lt = is_pm1(lc)? NULL: lc;
GEN Clt = mul_content(C, lt);
GEN C2lt = mul_content(C,Clt);
piv = special_pivot(M_L);
if (!piv) return NULL;
if (DEBUGLEVEL>3) fprintferr("special_pivot output:\n%Z\n",piv);
r = lg(piv)-1;
list = cgetg(r+1, t_COL);
C2ltpol = C2lt? gmul(C2lt,pol): pol;
for (i = 1;;)
{
pari_sp av = avma;
if (DEBUGLEVEL)
fprintferr("nf_LLL_cmbf: checking factor %ld (avma - bot = %lu)\n",
i, avma - bot);
y = chk_factors_get(lt, famod, gel(piv,i), Tpk, pk);
if (DEBUGLEVEL>2) fprintferr("... mod p^k (avma - bot = %lu)\n", avma-bot);
if (! (y = nf_pol_lift(y, bound, T)) ) return NULL;
if (DEBUGLEVEL>2) fprintferr("... lifted (avma - bot = %lu)\n", avma-bot);
y = gerepilecopy(av, y);
/* y is the candidate factor */
pol = RgXQX_divrem(C2ltpol, y, nfT, ONLY_DIVIDES);
if (!pol) return NULL;
y = Q_primpart(y);
gel(list,i) = QXQX_normalize(y, nfT);
if (++i >= r) break;
if (C2lt) pol = Q_primpart(pol);
if (lt) lt = absi(leading_term(pol));
Clt = mul_content(C, lt);
C2lt = mul_content(C,Clt);
C2ltpol = C2lt? gmul(C2lt,pol): pol;
}
y = Q_primpart(pol);
gel(list,i) = QXQX_normalize(y, nfT); return list;
}
// Digit reversal
GEN
rev(GEN n, long B)
{
pari_sp av = avma;
if (typ(n) != t_INT)
pari_err_TYPE("rev", n);
GEN m = modis(n, B);
n = divis(n, B);
pari_sp btop = avma, st_lim = stack_lim(btop, 1);
while (signe(n)) {
m = addis(mulis(m, B), smodis(n, B));
n = divis(n, B);
if (low_stack(st_lim, stack_lim(btop, 1)))
gerepileall(btop, 2, &m, &n);
}
m = gerepilecopy(av, m);
return m;
}
GEN
shallowconcat1(GEN x)
{
pari_sp av = avma;
long lx, t, i;
GEN z;
switch(typ(x))
{
case t_VEC:
lx = lg(x);
if (lx==1) pari_err_DOMAIN("concat","vector","=",x,x);
break;
case t_LIST:
if (list_typ(x)!=t_LIST_RAW) pari_err_TYPE("concat",x);
if (!list_data(x)) pari_err_DOMAIN("concat","vector","=",x,x);
x = list_data(x); lx = lg(x);
break;
default:
pari_err_TYPE("concat",x);
return NULL; /* not reached */
}
if (lx==2) return gel(x,1);
z = gel(x,1); t = typ(z); i = 2;
if (is_matvec_t(t) || t == t_VECSMALL || t == t_STR)
{ /* detect a "homogeneous" object: catmany is faster */
for (; i<lx; i++)
if (typ(gel(x,i)) != t) break;
z = catmany(x + 1, x + i-1, t);
}
for (; i<lx; i++) {
z = shallowconcat(z, gel(x,i));
if (gc_needed(av,3))
{
if (DEBUGMEM>1) pari_warn(warnmem,"concat: i = %ld", i);
z = gerepilecopy(av, z);
}
}
return z;
}
GEN
F2xq_ellgens(GEN a2, GEN a6, GEN ch, GEN D, GEN m, GEN T)
{
GEN P;
pari_sp av = avma;
struct _F2xqE e;
e.a2=a2; e.a6=a6; e.T=T;
switch(lg(D)-1)
{
case 0:
return cgetg(1,t_VEC);
case 1:
P = gen_gener(gel(D,1), (void*)&e, &F2xqE_group);
P = mkvec(F2xqE_changepoint(P, ch, T));
break;
default:
P = gen_ellgens(gel(D,1), gel(D,2), m, (void*)&e, &F2xqE_group,
_F2xqE_pairorder);
gel(P,1) = F2xqE_changepoint(gel(P,1), ch, T);
gel(P,2) = F2xqE_changepoint(gel(P,2), ch, T);
break;
}
return gerepilecopy(av, P);
}
/* return the roots of pol in nf */
GEN
nfroots(GEN nf,GEN pol)
{
pari_sp av = avma;
GEN A,g, T;
long d;
if (!nf) return nfrootsQ(pol);
nf = checknf(nf); T = gel(nf,1);
if (typ(pol) != t_POL) pari_err(notpoler,"nfroots");
if (varncmp(varn(pol), varn(T)) >= 0)
pari_err(talker,"polynomial variable must have highest priority in nfroots");
d = degpol(pol);
if (d == 0) return cgetg(1,t_VEC);
if (d == 1)
{
A = gneg_i(gdiv(gel(pol,2),gel(pol,3)));
return gerepilecopy(av, mkvec( basistoalg(nf,A) ));
}
A = fix_relative_pol(nf,pol,0);
A = Q_primpart( lift_intern(A) );
if (DEBUGLEVEL>3) fprintferr("test if polynomial is square-free\n");
g = nfgcd(A, derivpol(A), T, gel(nf,4));
if (degpol(g))
{ /* not squarefree */
g = QXQX_normalize(g, T);
A = RgXQX_div(A,g,T);
}
A = QXQX_normalize(A, T);
A = Q_primpart(A);
A = nfsqff(nf,A,1);
A = RgXQV_to_mod(A, T);
return gerepileupto(av, gen_sort(A, 0, cmp_pol));
}
GEN
matconcat(GEN v)
{
pari_sp av = avma;
return gerepilecopy(av, shallowmatconcat(v));
}
GEN
concat1(GEN x)
{
pari_sp av = avma;
return gerepilecopy(av, shallowconcat1(x));
}
GEN
bnflog(GEN bnf, GEN ell)
{
pari_sp av = avma;
return gerepilecopy(av, bnflog_i(bnf, ell));
}
/* Naive recombination of modular factors: combine up to maxK modular
* factors, degree <= klim and divisible by hint
*
* target = polynomial we want to factor
* famod = array of modular factors. Product should be congruent to
* target/lc(target) modulo p^a
* For true factors: S1,S2 <= p^b, with b <= a and p^(b-a) < 2^31 */
static GEN
nfcmbf(nfcmbf_t *T, GEN p, long a, long maxK, long klim)
{
GEN pol = T->pol, nf = T->nf, famod = T->fact, dn = T->dn;
GEN bound = T->bound;
GEN nfpol = gel(nf,1);
long K = 1, cnt = 1, i,j,k, curdeg, lfamod = lg(famod)-1, dnf = degpol(nfpol);
GEN res = cgetg(3, t_VEC);
pari_sp av0 = avma;
GEN pk = gpowgs(p,a), pks2 = shifti(pk,-1);
GEN ind = cgetg(lfamod+1, t_VECSMALL);
GEN degpol = cgetg(lfamod+1, t_VECSMALL);
GEN degsofar = cgetg(lfamod+1, t_VECSMALL);
GEN listmod = cgetg(lfamod+1, t_COL);
GEN fa = cgetg(lfamod+1, t_COL);
GEN lc = absi(leading_term(pol)), lt = is_pm1(lc)? NULL: lc;
GEN C2ltpol, C = T->L->topowden, Tpk = T->L->Tpk;
GEN Clt = mul_content(C, lt);
GEN C2lt = mul_content(C,Clt);
const double Bhigh = get_Bhigh(lfamod, dnf);
trace_data _T1, _T2, *T1, *T2;
pari_timer ti;
TIMERstart(&ti);
if (maxK < 0) maxK = lfamod-1;
C2ltpol = C2lt? gmul(C2lt,pol): pol;
{
GEN q = ceil_safe(sqrtr(T->BS_2));
GEN t1,t2, ltdn, lt2dn;
GEN trace1 = cgetg(lfamod+1, t_MAT);
GEN trace2 = cgetg(lfamod+1, t_MAT);
ltdn = mul_content(lt, dn);
lt2dn= mul_content(ltdn, lt);
for (i=1; i <= lfamod; i++)
{
pari_sp av = avma;
GEN P = gel(famod,i);
long d = degpol(P);
degpol[i] = d; P += 2;
t1 = gel(P,d-1);/* = - S_1 */
t2 = gsqr(t1);
if (d > 1) t2 = gsub(t2, gmul2n(gel(P,d-2), 1));
/* t2 = S_2 Newton sum */
t2 = typ(t2)!=t_INT? FpX_rem(t2, Tpk, pk): modii(t2, pk);
if (lt)
{
if (typ(t2)!=t_INT) {
t1 = FpX_red(gmul(ltdn, t1), pk);
t2 = FpX_red(gmul(lt2dn,t2), pk);
} else {
t1 = remii(mulii(ltdn, t1), pk);
t2 = remii(mulii(lt2dn,t2), pk);
}
}
gel(trace1,i) = gclone( nf_bestlift(t1, NULL, T->L) );
gel(trace2,i) = gclone( nf_bestlift(t2, NULL, T->L) ); avma = av;
}
T1 = init_trace(&_T1, trace1, T->L, q);
T2 = init_trace(&_T2, trace2, T->L, q);
for (i=1; i <= lfamod; i++) {
gunclone(gel(trace1,i));
gunclone(gel(trace2,i));
}
}
degsofar[0] = 0; /* sentinel */
/* ind runs through strictly increasing sequences of length K,
* 1 <= ind[i] <= lfamod */
nextK:
if (K > maxK || 2*K > lfamod) goto END;
if (DEBUGLEVEL > 3)
fprintferr("\n### K = %d, %Z combinations\n", K,binomial(utoipos(lfamod), K));
setlg(ind, K+1); ind[1] = 1;
i = 1; curdeg = degpol[ind[1]];
for(;;)
{ /* try all combinations of K factors */
for (j = i; j < K; j++)
{
degsofar[j] = curdeg;
ind[j+1] = ind[j]+1; curdeg += degpol[ind[j+1]];
}
if (curdeg <= klim && curdeg % T->hint == 0) /* trial divide */
{
GEN t, y, q, list;
pari_sp av;
av = avma;
/* d - 1 test */
if (T1)
{
t = get_trace(ind, T1);
if (rtodbl(QuickNormL2(t,DEFAULTPREC)) > Bhigh)
{
if (DEBUGLEVEL>6) fprintferr(".");
avma = av; goto NEXT;
}
}
/* d - 2 test */
if (T2)
{
t = get_trace(ind, T2);
if (rtodbl(QuickNormL2(t,DEFAULTPREC)) > Bhigh)
{
if (DEBUGLEVEL>3) fprintferr("|");
avma = av; goto NEXT;
}
}
avma = av;
y = lt; /* full computation */
for (i=1; i<=K; i++)
{
GEN q = gel(famod, ind[i]);
if (y) q = gmul(y, q);
y = FqX_centermod(q, Tpk, pk, pks2);
}
y = nf_pol_lift(y, bound, T);
if (!y)
{
if (DEBUGLEVEL>3) fprintferr("@");
avma = av; goto NEXT;
}
/* try out the new combination: y is the candidate factor */
q = RgXQX_divrem(C2ltpol, y, nfpol, ONLY_DIVIDES);
if (!q)
{
if (DEBUGLEVEL>3) fprintferr("*");
avma = av; goto NEXT;
}
/* found a factor */
list = cgetg(K+1, t_VEC);
gel(listmod,cnt) = list;
for (i=1; i<=K; i++) list[i] = famod[ind[i]];
y = Q_primpart(y);
gel(fa,cnt++) = QXQX_normalize(y, nfpol);
/* fix up pol */
pol = q;
for (i=j=k=1; i <= lfamod; i++)
{ /* remove used factors */
if (j <= K && i == ind[j]) j++;
else
{
famod[k] = famod[i];
update_trace(T1, k, i);
update_trace(T2, k, i);
degpol[k] = degpol[i]; k++;
}
}
lfamod -= K;
if (lfamod < 2*K) goto END;
i = 1; curdeg = degpol[ind[1]];
if (C2lt) pol = Q_primpart(pol);
if (lt) lt = absi(leading_term(pol));
Clt = mul_content(C, lt);
C2lt = mul_content(C,Clt);
C2ltpol = C2lt? gmul(C2lt,pol): pol;
if (DEBUGLEVEL > 2)
{
fprintferr("\n"); msgTIMER(&ti, "to find factor %Z",y);
fprintferr("remaining modular factor(s): %ld\n", lfamod);
}
continue;
}
NEXT:
for (i = K+1;;)
{
if (--i == 0) { K++; goto nextK; }
if (++ind[i] <= lfamod - K + i)
{
curdeg = degsofar[i-1] + degpol[ind[i]];
if (curdeg <= klim) break;
}
}
}
END:
if (degpol(pol) > 0)
{ /* leftover factor */
if (signe(leading_term(pol)) < 0) pol = gneg_i(pol);
if (C2lt && lfamod < 2*K) pol = QXQX_normalize(Q_primpart(pol), nfpol);
setlg(famod, lfamod+1);
gel(listmod,cnt) = shallowcopy(famod);
gel(fa,cnt++) = pol;
}
if (DEBUGLEVEL>6) fprintferr("\n");
if (cnt == 2) {
avma = av0;
gel(res,1) = mkvec(T->pol);
gel(res,2) = mkvec(T->fact);
}
else
{
setlg(listmod, cnt); setlg(fa, cnt);
gel(res,1) = fa;
gel(res,2) = listmod;
res = gerepilecopy(av0, res);
}
return res;
}
/* return the factorization of x in nf */
GEN
nffactor(GEN nf,GEN pol)
{
GEN A,g,y,p1,T, rep = cgetg(3, t_MAT);
long l, j, dA;
pari_sp av = avma;
pari_timer ti;
if (DEBUGLEVEL>2) { TIMERstart(&ti); fprintferr("\nEntering nffactor:\n"); }
nf = checknf(nf); T = gel(nf,1);
if (typ(pol) != t_POL) pari_err(notpoler,"nffactor");
if (varncmp(varn(pol), varn(T)) >= 0)
pari_err(talker,"polynomial variable must have highest priority in nffactor");
A = fix_relative_pol(nf,pol,0);
dA = degpol(A);
if (dA <= 0) {
avma = (pari_sp)(rep + 3);
return dA == 0? trivfact(): zerofact(varn(pol));
}
A = Q_primpart( QXQX_normalize(A, T) );
if (dA == 1) {
GEN c;
A = gerepilecopy(av, A); c = gel(A,2);
if (typ(c) == t_POL && degpol(c) > 0) gel(A,2) = mkpolmod(c, gcopy(T));
gel(rep,1) = mkcol(A);
gel(rep,2) = mkcol(gen_1); return rep;
}
if (degpol(T) == 1)
return gerepileupto(av, factpol(Q_primpart(simplify(pol)), 0));
A = Q_primpart( lift_intern(A) );
g = nfgcd(A, derivpol(A), T, gel(nf,4));
A = QXQX_normalize(A, T);
A = Q_primpart(A);
if (DEBUGLEVEL>2) msgTIMER(&ti, "squarefree test");
if (degpol(g))
{ /* not squarefree */
pari_sp av1;
GEN ex;
g = QXQX_normalize(g, T);
A = RgXQX_div(A,g, T);
y = nfsqff(nf,A,0); av1 = avma;
l = lg(y);
ex=(GEN)gpmalloc(l * sizeof(long));
for (j=l-1; j>=1; j--)
{
GEN fact = lift(gel(y,j)), quo = g, q;
long e = 0;
for(e = 1;; e++)
{
q = RgXQX_divrem(quo,fact,T, ONLY_DIVIDES);
if (!q) break;
quo = q;
}
ex[j] = e;
}
avma = av1; y = gerepileupto(av, RgXQXV_to_mod(y,T));
p1 = cgetg(l, t_COL); for (j=l-1; j>=1; j--) gel(p1,j) = utoipos(ex[j]);
free(ex);
}
else
{
y = gerepileupto(av, RgXQXV_to_mod(nfsqff(nf,A,0), T));
l = lg(y);
p1 = cgetg(l, t_COL); for (j=l-1; j>=1; j--) gel(p1,j) = gen_1;
}
if (DEBUGLEVEL>3)
fprintferr("number of factor(s) found: %ld\n", lg(y)-1);
gel(rep,1) = y;
gel(rep,2) = p1; return sort_factor(rep, cmp_pol);
}
/* return the factorization of the square-free polynomial x.
The coeffs of x are in Z_nf and its leading term is a rational integer.
deg(x) > 1, deg(nfpol) > 1
If fl = 1, return only the roots of x in nf
If fl = 2, as fl=1 if pol splits, [] otherwise */
static GEN
nfsqff(GEN nf, GEN pol, long fl)
{
long n, nbf, dpol = degpol(pol);
GEN pr, C0, polbase, init_fa = NULL;
GEN N2, rep, polmod, polred, lt, nfpol = gel(nf,1);
nfcmbf_t T;
nflift_t L;
pari_timer ti, ti_tot;
if (DEBUGLEVEL>2) { TIMERstart(&ti); TIMERstart(&ti_tot); }
n = degpol(nfpol);
polbase = unifpol(nf, pol, t_COL);
if (typ(polbase) != t_POL) pari_err(typeer, "nfsqff");
polmod = lift_intern( unifpol(nf, pol, t_POLMOD) );
if (dpol == 1) return mkvec(QXQX_normalize(polmod, nfpol));
/* heuristic */
if (dpol*3 < n)
{
GEN z, t;
long i;
if (DEBUGLEVEL>2) fprintferr("Using Trager's method\n");
z = (GEN)polfnf(polmod, nfpol)[1];
if (fl) {
long l = lg(z);
for (i = 1; i < l; i++)
{
t = gel(z,i); if (degpol(t) > 1) break;
gel(z,i) = gneg(gdiv(gel(t,2), gel(t,3)));
}
setlg(z, i);
if (fl == 2 && i != l) return cgetg(1,t_VEC);
}
return z;
}
nbf = nf_pick_prime(5, nf, polbase, fl, <, &init_fa, &pr, &L.Tp);
if (fl == 2 && nbf < dpol) return cgetg(1,t_VEC);
if (nbf <= 1)
{
if (!fl) return mkvec(QXQX_normalize(polmod, nfpol)); /* irreducible */
if (!nbf) return cgetg(1,t_VEC); /* no root */
}
if (DEBUGLEVEL>2) {
msgTIMER(&ti, "choice of a prime ideal");
fprintferr("Prime ideal chosen: %Z\n", pr);
}
pol = simplify_i(lift(polmod));
L.tozk = gel(nf,8);
L.topow= Q_remove_denom(gel(nf,7), &L.topowden);
T.ZC = L2_bound(nf, L.tozk, &(T.dn));
T.Br = nf_root_bounds(pol, nf); if (lt) T.Br = gmul(T.Br, lt);
if (fl) C0 = normlp(T.Br, 2, n);
else C0 = nf_factor_bound(nf, polbase); /* bound for T_2(Q_i), Q | P */
T.bound = mulrr(T.ZC, C0); /* bound for |Q_i|^2 in Z^n on chosen Z-basis */
N2 = mulsr(dpol*dpol, normlp(T.Br, 4, n)); /* bound for T_2(lt * S_2) */
T.BS_2 = mulrr(T.ZC, N2); /* bound for |S_2|^2 on chosen Z-basis */
if (DEBUGLEVEL>2) {
msgTIMER(&ti, "bound computation");
fprintferr(" 1) T_2 bound for %s: %Z\n", fl?"root":"factor", C0);
fprintferr(" 2) Conversion from T_2 --> | |^2 bound : %Z\n", T.ZC);
fprintferr(" 3) Final bound: %Z\n", T.bound);
}
L.p = gel(pr,1);
if (L.Tp && degpol(L.Tp) == 1) L.Tp = NULL;
bestlift_init(0, nf, pr, T.bound, &L);
if (DEBUGLEVEL>2) TIMERstart(&ti);
polred = ZqX_normalize(polbase, lt, &L); /* monic */
if (fl) {
GEN z = nf_DDF_roots(pol, polred, nfpol, lt, init_fa, nbf, fl, &L);
if (lg(z) == 1) return cgetg(1, t_VEC);
return z;
}
{
pari_sp av = avma;
if (L.Tp)
rep = FqX_split_all(init_fa, L.Tp, L.p);
else
{
long d;
rep = cgetg(dpol + 1, t_VEC); gel(rep,1) = FpX_red(polred,L.p);
d = FpX_split_Berlekamp((GEN*)(rep + 1), L.p);
setlg(rep, d + 1);
}
T.fact = gerepilecopy(av, sort_vecpol(rep, &cmp_pol));
}
if (DEBUGLEVEL>2) msgTIMER(&ti, "splitting mod %Z", pr);
T.pr = pr;
T.L = &L;
T.polbase = polbase;
T.pol = pol;
T.nf = nf;
T.hint = 1; /* useless */
rep = nf_combine_factors(&T, polred, L.p, L.k, dpol-1);
if (DEBUGLEVEL>2)
fprintferr("Total Time: %ld\n===========\n", TIMER(&ti_tot));
return rep;
}
static GEN
nf_LLL_cmbf(nfcmbf_t *T, GEN p, long k, long rec)
{
nflift_t *L = T->L;
GEN pk = L->pk, PRK = L->prk, PRKinv = L->iprk, GSmin = L->GSmin;
GEN Tpk = L->Tpk;
GEN famod = T->fact, nf = T->nf, ZC = T->ZC, Br = T->Br;
GEN Pbase = T->polbase, P = T->pol, dn = T->dn;
GEN nfT = gel(nf,1);
GEN Btra;
long dnf = degpol(nfT), dP = degpol(P);
double BitPerFactor = 0.5; /* nb bits / modular factor */
long i, C, tmax, n0;
GEN lP, Bnorm, Tra, T2, TT, CM_L, m, list, ZERO;
double Bhigh;
pari_sp av, av2, lim;
long ti_LLL = 0, ti_CF = 0;
pari_timer ti2, TI;
lP = absi(leading_term(P));
if (is_pm1(lP)) lP = NULL;
n0 = lg(famod) - 1;
/* Lattice: (S PRK), small vector (vS vP). To find k bound for the image,
* write S = S1 q + S0, P = P1 q + P0
* |S1 vS + P1 vP|^2 <= Bhigh for all (vS,vP) assoc. to true factors */
Btra = mulrr(ZC, mulsr(dP*dP, normlp(Br, 2, dnf)));
Bhigh = get_Bhigh(n0, dnf);
C = (long)ceil(sqrt(Bhigh/n0)) + 1; /* C^2 n0 ~ Bhigh */
Bnorm = dbltor( n0 * C * C + Bhigh );
ZERO = zeromat(n0, dnf);
av = avma; lim = stack_lim(av, 1);
TT = cgetg(n0+1, t_VEC);
Tra = cgetg(n0+1, t_MAT);
for (i=1; i<=n0; i++) TT[i] = 0;
CM_L = gscalsmat(C, n0);
/* tmax = current number of traces used (and computed so far) */
for(tmax = 0;; tmax++)
{
long a, b, bmin, bgood, delta, tnew = tmax + 1, r = lg(CM_L)-1;
GEN oldCM_L, M_L, q, S1, P1, VV;
int first = 1;
/* bound for f . S_k(genuine factor) = ZC * bound for T_2(S_tnew) */
Btra = mulrr(ZC, mulsr(dP*dP, normlp(Br, 2*tnew, dnf)));
bmin = logint(ceil_safe(sqrtr(Btra)), gen_2, NULL);
if (DEBUGLEVEL>2)
fprintferr("\nLLL_cmbf: %ld potential factors (tmax = %ld, bmin = %ld)\n",
r, tmax, bmin);
/* compute Newton sums (possibly relifting first) */
if (gcmp(GSmin, Btra) < 0)
{
nflift_t L1;
GEN polred;
bestlift_init(k<<1, nf, T->pr, Btra, &L1);
polred = ZqX_normalize(Pbase, lP, &L1);
k = L1.k;
pk = L1.pk;
PRK = L1.prk;
PRKinv = L1.iprk;
GSmin = L1.GSmin;
Tpk = L1.Tpk;
famod = hensel_lift_fact(polred, famod, Tpk, p, pk, k);
for (i=1; i<=n0; i++) TT[i] = 0;
}
for (i=1; i<=n0; i++)
{
GEN h, lPpow = lP? gpowgs(lP, tnew): NULL;
GEN z = polsym_gen(gel(famod,i), gel(TT,i), tnew, Tpk, pk);
gel(TT,i) = z;
h = gel(z,tnew+1);
/* make Newton sums integral */
lPpow = mul_content(lPpow, dn);
if (lPpow) h = FpX_red(gmul(h,lPpow), pk);
gel(Tra,i) = nf_bestlift(h, NULL, L); /* S_tnew(famod) */
}
/* compute truncation parameter */
if (DEBUGLEVEL>2) { TIMERstart(&ti2); TIMERstart(&TI); }
oldCM_L = CM_L;
av2 = avma;
b = delta = 0; /* -Wall */
AGAIN:
M_L = Q_div_to_int(CM_L, utoipos(C));
VV = get_V(Tra, M_L, PRK, PRKinv, pk, &a);
if (first)
{ /* initialize lattice, using few p-adic digits for traces */
bgood = (long)(a - max(32, BitPerFactor * r));
b = max(bmin, bgood);
delta = a - b;
}
else
{ /* add more p-adic digits and continue reduction */
if (a < b) b = a;
b = max(b-delta, bmin);
if (b - delta/2 < bmin) b = bmin; /* near there. Go all the way */
}
/* restart with truncated entries */
q = int2n(b);
P1 = gdivround(PRK, q);
S1 = gdivround(Tra, q);
T2 = gsub(gmul(S1, M_L), gmul(P1, VV));
m = vconcat( CM_L, T2 );
if (first)
{
first = 0;
m = shallowconcat( m, vconcat(ZERO, P1) );
/* [ C M_L 0 ]
* m = [ ] square matrix
* [ T2' PRK ] T2' = Tra * M_L truncated
*/
}
CM_L = LLL_check_progress(Bnorm, n0, m, b == bmin, /*dbg:*/ &ti_LLL);
if (DEBUGLEVEL>2)
fprintferr("LLL_cmbf: (a,b) =%4ld,%4ld; r =%3ld -->%3ld, time = %ld\n",
a,b, lg(m)-1, CM_L? lg(CM_L)-1: 1, TIMER(&TI));
if (!CM_L) { list = mkcol(QXQX_normalize(P,nfT)); break; }
if (b > bmin)
{
CM_L = gerepilecopy(av2, CM_L);
goto AGAIN;
}
if (DEBUGLEVEL>2) msgTIMER(&ti2, "for this trace");
i = lg(CM_L) - 1;
if (i == r && gequal(CM_L, oldCM_L))
{
CM_L = oldCM_L;
avma = av2; continue;
}
if (i <= r && i*rec < n0)
{
pari_timer ti;
if (DEBUGLEVEL>2) TIMERstart(&ti);
list = nf_chk_factors(T, P, Q_div_to_int(CM_L,utoipos(C)), famod, pk);
if (DEBUGLEVEL>2) ti_CF += TIMER(&ti);
if (list) break;
CM_L = gerepilecopy(av2, CM_L);
}
if (low_stack(lim, stack_lim(av,1)))
{
if(DEBUGMEM>1) pari_warn(warnmem,"nf_LLL_cmbf");
gerepileall(av, Tpk? 9: 8,
&CM_L,&TT,&Tra,&famod,&pk,&GSmin,&PRK,&PRKinv,&Tpk);
}
}
if (DEBUGLEVEL>2)
fprintferr("* Time LLL: %ld\n* Time Check Factor: %ld\n",ti_LLL,ti_CF);
return list;
}
