double test_build_isom1(slong degree, slong prime) {
fmpz_t p;
fmpz_init_set_ui(p, prime);
flint_rand_t state;
flint_randinit(state);
fmpz_mod_poly_t f1, f2;
fmpz_mod_poly_init(f1, p);
fmpz_mod_poly_init(f2, p);
fmpz_mod_poly_randtest_monic_irreducible(f1, state, degree + 1);
NmodMinPoly fmpzMinPoly;
while (fmpz_mod_poly_degree(f2) < degree) {
fmpz_mod_poly_randtest_not_zero(f2, state, degree);
fmpzMinPoly.minimal_polynomial(f2, f2, f1);
}
timeit_t time;
timeit_start(time);
FFIsomorphism ffIsomorphism(f1, f2);
timeit_stop(time);
fmpz_clear(p);
flint_randclear(state);
fmpz_mod_poly_clear(f1);
fmpz_mod_poly_clear(f2);
return (double) time->wall / 1000.0;
}
void test_build_isom(slong degree, slong prime) {
Util util;
cout << "characteristic: " << prime << "\n";
cout << "extension degree: " << degree << "\n";
cout << "cyclotomic extension degree: " << util.compute_multiplicative_order(prime, degree) << "\n";
fmpz_t p;
fmpz_init_set_ui(p, prime);
flint_rand_t state;
flint_randinit(state);
fmpz_mod_poly_t f1, f2;
fmpz_mod_poly_init(f1, p);
fmpz_mod_poly_init(f2, p);
cout << "building finite fields...\n";
fmpz_mod_poly_randtest_monic_irreducible(f1, state, degree + 1);
NmodMinPoly fmpzMinPoly;
while (fmpz_mod_poly_degree(f2) < degree) {
fmpz_mod_poly_randtest_not_zero(f2, state, degree);
fmpzMinPoly.minimal_polynomial(f2, f2, f1);
}
cout << "building an isomorphism...\n";
timeit_t time;
timeit_start(time);
FFIsomorphism ffIsomorphism(f1, f2);
timeit_stop(time);
cout << "time: " << (double) time->wall / 1000.0 << "\n";
cout << "testing the isomorphism... ";
fmpz_mod_poly_t temp;
fmpz_mod_poly_init(temp, p);
// set temp = x
fmpz_mod_poly_set_coeff_ui(temp, 1, 1);
// compute the image of x
ffIsomorphism.compute_image(temp, temp);
// the image of x should be a root of f1 in F_p[X]/<f2>
fmpz_mod_poly_compose_mod(temp, f1, temp, f2);
if (fmpz_mod_poly_is_zero(temp))
cout << "ok\n";
else
cout << "ooops\n";
fmpz_clear(p);
flint_randclear(state);
fmpz_mod_poly_clear(f1);
fmpz_mod_poly_clear(f2);
fmpz_mod_poly_clear(temp);
}
void FFIsomBaseChange::change_basis(nmod_poly_t result, const nmod_poly_t f, const nmod_poly_t g,
const nmod_poly_t modulus) {
nmod_poly_t min_poly;
nmod_poly_init(min_poly, f->mod.n);
nmod_poly_t modulus_inv_rev1;
nmod_poly_t modulus_inv_rev2;
nmod_poly_init(modulus_inv_rev1, modulus->mod.n);
nmod_poly_init(modulus_inv_rev2, modulus->mod.n);
slong degree = nmod_poly_degree(modulus);
// compute 1 / rev(modulus, degree + 1) mod x^degree
nmod_poly_reverse(modulus_inv_rev1, modulus, degree + 1);
nmod_poly_inv_series_newton(modulus_inv_rev1, modulus_inv_rev1, degree);
// compute 1 / rev(modulus, degree + 1) mod x^{degree - 1}
nmod_poly_reverse(modulus_inv_rev2, modulus, degree + 1);
nmod_poly_inv_series_newton(modulus_inv_rev2, modulus_inv_rev2, degree - 1);
// compute the minimal polynomial of f
NmodMinPoly nmodMinPoly;
nmodMinPoly.minimal_polynomial(min_poly, f, modulus, modulus_inv_rev2);
mp_limb_t *dual = new mp_limb_t[degree];
for (slong i = 0; i < degree; i++)
dual[i] = 0;
// compute the dual basis image of x mod modulus
monomial_to_dual(dual, g, modulus, modulus_inv_rev1);
// compute the power projection <dual, f>
nmodMinPoly.project_powers(dual, dual, degree, f, modulus, modulus_inv_rev2);
// compute result such that result(f) = x
dual_to_monomial(result, dual, min_poly);
nmod_poly_clear(min_poly);
nmod_poly_clear(modulus_inv_rev1);
nmod_poly_clear(modulus_inv_rev2);
_nmod_vec_clear(dual);
}
void test_minpoly(slong degree) {
cout << "degree: " << degree << "\n";
mp_limb_t p = 9001;
flint_rand_t state;
flint_randinit(state);
nmod_poly_t minpoly, f, modulus;
nmod_poly_init(f, p);
nmod_poly_init(minpoly, p);
nmod_poly_init(modulus, p);
nmod_poly_randtest(f, state, degree - 1);
nmod_poly_randtest_monic_irreducible(modulus, state, degree);
timeit_t time;
timeit_start(time);
NmodMinPoly nmodMinPoly;
nmodMinPoly.minimal_polynomial(minpoly, f, modulus);
timeit_stop(time);
cout << "time: " << (double) time->wall / 1000.0 << "\n";
slong irr = nmod_poly_is_irreducible(minpoly);
nmod_poly_compose_mod(minpoly, minpoly, f, modulus);
if (irr && nmod_poly_is_zero(minpoly))
cout << "ok\n";
else
cout << "oops\n";
flint_randclear(state);
nmod_poly_clear(minpoly);
nmod_poly_clear(f);
nmod_poly_clear(modulus);
}
