void
acb_dirichlet_l_general(acb_t res, const acb_t s,
const dirichlet_group_t G, const dirichlet_char_t chi, slong prec)
{
/* this cutoff is probably too conservative when q is large */
if (arf_cmp_d(arb_midref(acb_realref(s)), 8 + 0.5 * prec / log(prec)) >= 0)
{
acb_dirichlet_l_euler_product(res, s, G, chi, prec);
}
else
{
slong wp = prec + n_clog(G->phi_q, 2);
acb_dirichlet_hurwitz_precomp_t pre;
acb_dirichlet_hurwitz_precomp_init_num(pre, s, acb_is_one(s), G->phi_q, wp);
acb_dirichlet_l_hurwitz(res, s, pre, G, chi, prec);
acb_dirichlet_hurwitz_precomp_clear(pre);
}
}
void deformation_precisions(prec_t *prec,
const fmpz_t p, long a, long n, long d, long degR)
{
long f;
prec->N0 = _zeta_function(p, a, n, d);
prec->N1 = _frobq(&(prec->r), &(prec->s), p, a, n, d, prec->N0);
prec->N2 = _frobp(a, prec->N1, prec->r, prec->s);
prec->m = (long) (1.1 * (*p * prec->N1));
prec->K = (degR + 1) * prec->m;
f = 2 * (prec->r + prec->s) + (n - 1);
prec->N3 = prec->N2 + (prec->r + prec->s) + f * n_clog((prec->K + *p - 1) / *p, *p);
prec->N3i = prec->N2 + (prec->r + prec->s) + f * n_clog(prec->K, *p);
prec->N3w = prec->N3 + (f + 1) * n_clog(prec->K, *p);
prec->N3iw = prec->N3i + (f + 1) * n_clog((prec->K + *p - 1) / *p, *p);
prec->N4 = prec->N2 + f * (n_clog(prec->K, *p) + n_clog((prec->K + *p - 1) / *p, *p));
prec->denR = NULL;
}
void diagfrob(padic_mat_t F, const fmpz *a, long n, long d, long N,
const padic_ctx_t ctx, const int verbose)
{
const fmpz *P = ctx->p;
const long p = fmpz_get_si(P);
const long delta = diagfrob_delta(n, P);
const long N2 = N - n + 2 * (padic_val_fac_ui(n - 1, P) + n + delta);
const long M = (p * p * (N2 + n_clog(N2 + 3, p) + 4) + (p - 2))
/ (p - 1) - 1;
mon_t *B;
long *iB, lenB, lo, hi;
long i, j, k, *u, *v;
long **C, *lenC;
fmpz *dinv, **mu;
clock_t t0 = 0, t1 = 0;
double t;
gmc_basis_sets(&B, &iB, &lenB, &lo, &hi, n, d);
if (verbose)
{
printf("Frobenius on the diagonal fibre\n");
printf("N = %ld\n", N);
printf("N2 = %ld\n", N2);
printf("M = %ld\n", M);
}
if (verbose)
{
printf("Basis for H_{dR}^%ld(U)\n", n);
gmc_basis_print(B, iB, lenB, n, d);
printf("\n");
}
C = malloc((n + 1) * sizeof(long *));
C[0] = malloc((n + 1) * lenB * sizeof(long));
for (i = 1; i <= n; i++)
{
C[i] = C[i-1] + lenB;
}
lenC = malloc((n + 1) * sizeof(long));
for (i = 0; i <= n; i++)
{
_congruence_class(C[i], &lenC[i], i, B, lenB, n, d, p);
}
dinv = _fmpz_vec_init(M/p + 1);
mu = malloc((n + 1) * sizeof(fmpz *));
for (i = 0; i <= n; i++)
{
mu[i] = _fmpz_vec_init(((M + 1 + p - 1) / p) * lenC[i]);
}
u = malloc((n + 1) * sizeof(long));
v = malloc((n + 1) * sizeof(long));
if (verbose)
{
printf("Sequence d^{-r}\n");
t0 = clock();
}
precompute_dinv(dinv, M, d, p, N2);
if (verbose)
{
t1 = clock();
t = (double) (t1 - t0) / CLOCKS_PER_SEC;
printf("T = %f\n", t);
}
if (verbose)
{
printf("Sequence mu_{m}\n");
t0 = clock();
}
precompute_muex(mu, M, (const long **) C, lenC, a, n, p, N2); /* XXX */
if (verbose)
{
t1 = clock();
t = (double) (t1 - t0) / CLOCKS_PER_SEC;
printf("T = %f\n", t);
}
if (verbose)
{
printf("Matrix F\n");
t0 = clock();
}
for (i = 0; i < lenB; i++)
for (j = 0; j < lenB; j++)
{
for (k = 0; k <= n; k++)
{
u[k] = mon_get_exp(B[i], k);
v[k] = mon_get_exp(B[j], k);
if ((p * (u[k] + 1) - (v[k] + 1)) % d != 0)
{
break;
}
}
if (k <= n)
{
fmpz_zero(padic_mat_entry(F, i, j));
}
else
{
long o;
entry(padic_mat_entry(F, i, j), &o,
u, v, a, dinv, (const fmpz **) mu, M, (const long **) C, lenC, n, d, p, N, N2);
if (o != - delta)
{
fmpz_t w;
fmpz_init(w);
fmpz_pow_ui(w, P, o + delta);
fmpz_mul(padic_mat_entry(F, i, j),
padic_mat_entry(F, i, j), w);
fmpz_clear(w);
}
}
}
padic_mat_val(F) = - delta;
_padic_mat_canonicalise(F, ctx);
if (verbose)
{
t1 = clock();
t = (double) (t1 - t0) / CLOCKS_PER_SEC;
printf("T = %f\n", t);
}
_fmpz_vec_clear(dinv, M/p + 1);
for (i = 0; i <= n; i++)
{
_fmpz_vec_clear(mu[i], ((M + 1 + p - 1) / p) * lenC[i]);
}
free(mu);
free(C[0]);
free(C);
free(lenC);
free(u);
free(v);
free(B);
free(iB);
}
// Version Fq
void fq_poly_compose_mod_kedlaya_umans(fq_poly_t fg, const fq_poly_t f, const fq_poly_t g, const fq_poly_t h, slong d, fq_ctx_t ctx) {
slong n, i, j, m, dm, N, Nm, degree;
fmpz* p;
fmpz_t q;
fq_multi_poly_t f_prime;
fq_struct *vect_beta, *vect_alpha, *vect_alpha2, *vect_eval;
fq_poly_t gi;
// Vérification des paramètres
n = FLINT_MAX(fq_poly_length(f,ctx),fq_poly_length(g,ctx));
i = fq_poly_length(h,ctx);
if(n >= i) {
printf("Erreur, f ou g n'a pas été modulé par h.\n");
exit(1);
}
// Les polynômes f et g étant réduits modulo h, n vaut le nombre de coefficients de h
n = i;
if(d < 2) {
printf("d < 2\n");
exit(1);
}
if(d >= n) {
printf("d >= n\n");
exit(1);
}
p = fq_ctx_prime(ctx);
degree = fq_ctx_degree(ctx);
m = n_clog(n,d);
dm = n_pow(d,m);
N = n_pow(d,m)*m*d;
Nm = N*m;
if(fmpz_cmp_ui(p,N) < 0) {
flint_printf("\nErreur, pas assez de points d'interpolation !\n");
flint_printf("\np tient sur un mot machine, utilisez donc la version fq_nmod !\n");
exit(1);
}
// Étape 1 //////////////////////////////
fq_multi_poly_init(f_prime, dm, d, m, ctx);
_fq_vec_zero(f_prime->poly, dm, ctx);
for(i = 0 ; i < n ; i++) {
fq_poly_get_coeff(&(f_prime->poly[i]),f,i,ctx);
}
// Étape 3 //////////////////////////////
vect_beta = _fq_vec_init(N,ctx);
for(i = 0 ; i < N ; i++) {
fmpz_poly_set_coeff_ui(vect_beta + i, 0, i);
}
vect_alpha = _fq_vec_init(N*m, ctx);
fq_poly_init(gi,ctx);
fq_poly_set(gi,g,ctx);
fq_poly_evaluate_fq_vec(vect_alpha, gi, vect_beta, N, ctx);
for(i = 1 ; i < m ; i++) {
// Étape 2 //////////////////////////////
// Calcul du g^(d^i) avec g^(d^i) = [ (g^(d^(i-1))) ^ d ] mod h
fq_poly_powmod_ui_binexp(gi,gi,d,h,ctx);
fq_poly_evaluate_fq_vec(vect_alpha+i*N, gi, vect_beta, N, ctx);
}
fq_poly_clear(gi, ctx);
// Transposition
// Passe de m lignes N colonnes
// à N lignes m colonnes ==> nécessaire pour EMM dans Fp
vect_alpha2 = _fq_vec_init(Nm,ctx);
for(i = 0 ; i < m ; i++) {
for(j = 0 ; j < N ; j++) {
fq_set(vect_alpha2 + j*m + i,vect_alpha + i*N + j,ctx);
}
}
vect_alpha = vect_alpha2;
// Étape 4 //////////////////////////////
// EMM
vect_eval = _fq_vec_init(N,ctx);
fq_multi_poly_multimodular(vect_eval, N, f_prime, vect_alpha, ctx);
_fq_vec_clear(vect_alpha,Nm,ctx);
fq_multi_poly_clear(f_prime,ctx);
// Étape 5 //////////////////////////////
fq_poly_interpolate_fq_vec_fast(fg, vect_beta, vect_eval, N, ctx);
_fq_vec_clear(vect_beta,N,ctx);
_fq_vec_clear(vect_eval,N,ctx);
// Étape 6 //////////////////////////////
fq_poly_rem(fg,fg,h,ctx);
}
