template<> void
PAlgebraModTmpl<zz_pX,vec_zz_pX,zz_pXModulus>::mapToFt(zz_pX& r,
const zz_pX& G,unsigned t,const zz_pX* rF1) const
{
int i = zmStar.indexOfRep(t);
if (i < 0) { r=zz_pX::zero(); return; }
if (rF1==NULL) { // Compute the representation "from scratch"
zz_pE::init(factors[i]); // work with the extension field GF_2[X]/Ft(X)
zz_pEX Ga=to_zz_pEX((zz_pX&)G);// G is polynomial over the extension field
r=rep(FindRoot(Ga)); // Find a root of G in this field
return;
}
// if rF1 is set, then use it instead, setting r = rF1(X^t) mod Ft(X)
zz_pXModulus Ft(factors[i]);
// long tInv = InvMod(t,m);
zz_pX X2t = PowerXMod(t,Ft); // X2t = X^t mod Ft
r = CompMod(*rF1,X2t,Ft); // r = F1(X2t) mod Ft
/* Debugging sanity-check: G(r)=0 in the extension field (Z/2Z)[X]/Ft(X)
zz_pE::init(factors[i]);
zz_pEX Ga=to_zz_pEX((zz_pX&)G);// G as a polynomial over the extension field
zz_pE ra =to_zz_pE(r); // r is an element in the extension field
eval(ra,Ga,ra); // ra = Ga(ra)
if (!IsZero(ra)) {// check that Ga(r)=0 in this extension field
cout << "rF1(X^t) mod Ft(X) != root of G mod Ft, t=" << t << endl;
exit(0);
}*******************************************************************/
}
void PAlgebraModDerived<type>::mapToFt(RX& w,
const RX& G,unsigned long t,const RX* rF1) const
{
if (isDryRun()) {
w = RX::zero();
return;
}
long i = zMStar.indexOfRep(t);
if (i < 0) { clear(w); return; }
if (rF1==NULL) { // Compute the representation "from scratch"
// special case
if (G == factors[i]) {
SetX(w);
return;
}
//special case
if (deg(G) == 1) {
w = -ConstTerm(G);
return;
}
// the general case: currently only works when r == 1
assert(r == 1);
REBak bak; bak.save();
RE::init(factors[i]); // work with the extension field GF_p[X]/Ft(X)
REX Ga;
conv(Ga, G); // G as a polynomial over the extension field
vec_RE roots;
FindRoots(roots, Ga); // Find roots of G in this field
RE* first = &roots[0];
RE* last = first + roots.length();
RE* smallest = min_element(first, last);
// make a canonical choice
w=rep(*smallest);
return;
}
// if rF1 is set, then use it instead, setting w = rF1(X^t) mod Ft(X)
RXModulus Ft(factors[i]);
// long tInv = InvMod(t,m);
RX X2t = PowerXMod(t,Ft); // X2t = X^t mod Ft
w = CompMod(*rF1,X2t,Ft); // w = F1(X2t) mod Ft
/* Debugging sanity-check: G(w)=0 in the extension field (Z/2Z)[X]/Ft(X)
RE::init(factors[i]);
REX Ga;
conv(Ga, G); // G as a polynomial over the extension field
RE ra;
conv(ra, w); // w is an element in the extension field
eval(ra,Ga,ra); // ra = Ga(ra)
if (!IsZero(ra)) {// check that Ga(w)=0 in this extension field
cout << "rF1(X^t) mod Ft(X) != root of G mod Ft, t=" << t << endl;
exit(0);
}*******************************************************************/
}
NTL_CLIENT
#include <algorithm> // defines count(...), min(...)
#include <iostream>
#include "NumbTh.h"
#include "PAlgebra.h"
// Generate the representation of Z[X]/(Phi_m(X),2) for the odd integer m
void PAlgebraModTwo::init(unsigned m)
{
if (m == zmStar.M()) return; // nothign to do
((PAlgebra&)zmStar).init(m); // initialize the structure of (Z/mZ)*, if needed
if (zmStar.M()==0 || zmStar.NSlots()==0) return; // error in zmStar
unsigned nSlots = zmStar.NSlots();
// Next compute the factors Ft of Phi_m(X) mod 2, for all t \in T
// GF2X PhimXmod = to_GF2X(zmStar.PhimX()); // Phi_m(X) mod 2
PhimXmod = to_GF2X(zmStar.PhimX()); // Phi_m(X) mod 2
EDF(factors, PhimXmod, zmStar.OrdTwo()); // equal-degree factorization
// It is left to order the factors according to their representatives
GF2XModulus F1(factors[0]); // We arbitrarily choose factors[0] as F1
for (unsigned i=1; i<nSlots; i++) {
unsigned t = zmStar.ith_rep(i); // Ft is minimal polynomial of x^{1/t} mod F1
unsigned tInv = rep(inv(to_zz_p(t))); // tInv = t^{-1} mod m
GF2X X2tInv = PowerXMod(tInv,F1); // X2tInv = X^{1/t} mod F1
IrredPolyMod(factors[i], X2tInv, F1);
}
/* Debugging sanity-check #1: we should have Ft= GCD(F1(X^t),Phi_m(X))
GF2XModulus Pm2(PhimXmod);
for (i=1; i<nSlots; i++) {
unsigned t = T[i];
GF2X X2t = PowerXMod(t,PhimXmod); // X2t = X^t mod Phi_m(X)
GF2X Ft = GCD(CompMod(F1,X2t,Pm2),Pm2);
if (Ft != factors[i]) {
cout << "Ft != F1(X^t) mod Phi_m(X), t=" << t << endl;
exit(0);
}
}*******************************************************************/
// Compute the CRT coefficients for the Ft's
crtCoeffs.SetLength(nSlots);
for (unsigned i=0; i<nSlots; i++) {
GF2X te = PhimXmod / factors[i]; // \prod_{j\ne i} Fj
te %= factors[i]; // \prod_{j\ne i} Fj mod Fi
InvMod(crtCoeffs[i], te, factors[i]);// \prod_{j\ne i} Fj^{-1} mod Fi
}
}
long DetIrredTest(const ZZ_pX& f)
{
if (deg(f) <= 0) return 0;
if (deg(f) == 1) return 1;
ZZ_pXModulus F;
build(F, f);
ZZ_pX h;
PowerXMod(h, ZZ_p::modulus(), F);
ZZ_pX s;
PowerCompose(s, h, F.n, F);
if (!IsX(s)) return 0;
FacVec fvec;
FactorInt(fvec, F.n);
return RecIrredTest(fvec.length()-1, h, F, fvec);
}
long ProbIrredTest(const ZZ_pX& f, long iter)
{
long n = deg(f);
if (n <= 0) return 0;
if (n == 1) return 1;
const ZZ& p = ZZ_p::modulus();
ZZ_pXModulus F;
build(F, f);
ZZ_pX b, r, s;
PowerXMod(b, p, F);
long i;
for (i = 0; i < iter; i++) {
random(r, n);
TraceMap(s, r, n, F, b);
if (deg(s) > 0) return 0;
}
if (p >= n) return 1;
long pp;
conv(pp, p);
if (n % pp != 0) return 1;
PowerCompose(s, b, n/pp, F);
return !IsX(s);
}
void PAlgebraModDerived<type>::mapToSlots(MappingData<type>& mappingData, const RX& G) const
{
assert(deg(G) > 0 && zMStar.getOrdP() % deg(G) == 0);
assert(LeadCoeff(G) == 1);
mappingData.G = G;
mappingData.degG = deg(mappingData.G);
long nSlots = zMStar.getNSlots();
long m = zMStar.getM();
mappingData.maps.resize(nSlots);
mapToF1(mappingData.maps[0],mappingData.G); // mapping from base-G to base-F1
for (long i=1; i<nSlots; i++)
mapToFt(mappingData.maps[i], mappingData.G, zMStar.ith_rep(i), &(mappingData.maps[0]));
REBak bak; bak.save();
RE::init(mappingData.G);
mappingData.contextForG.save();
if (deg(mappingData.G)==1) return;
mappingData.rmaps.resize(nSlots);
if (G == factors[0]) {
// an important special case
for (long i = 0; i < nSlots; i++) {
long t = zMStar.ith_rep(i);
long tInv = InvMod(t, m);
RX ct_rep;
PowerXMod(ct_rep, tInv, G);
RE ct;
conv(ct, ct_rep);
REX Qi;
SetCoeff(Qi, 1, 1);
SetCoeff(Qi, 0, -ct);
mappingData.rmaps[i] = Qi;
}
}
else
{
// the general case: currently only works when r == 1
assert(r == 1);
vec_REX FRts;
for (long i=0; i<nSlots; i++) {
// We need to lift Fi from R[Y] to (R[X]/G(X))[Y]
REX Qi;
long t, tInv=0;
if (i == 0) {
conv(Qi,factors[i]);
FRts=EDF(Qi, FrobeniusMap(Qi), deg(Qi)/deg(G));
// factor Fi over GF(p)[X]/G(X)
}
else {
t = zMStar.ith_rep(i);
tInv = InvMod(t, m);
}
// need to choose the right factor, the one that gives us back X
long j;
for (j=0; j<FRts.length(); j++) {
// lift maps[i] to (R[X]/G(X))[Y] and reduce mod j'th factor of Fi
REX FRtsj;
if (i == 0)
FRtsj = FRts[j];
else {
REX X2tInv = PowerXMod(tInv, FRts[j]);
IrredPolyMod(FRtsj, X2tInv, FRts[j]);
}
// FRtsj is the jth factor of factors[i] over the extension field.
// For j > 0, we save some time by computing it from the jth factor
// of factors[0] via a minimal polynomial computation.
REX GRti;
conv(GRti, mappingData.maps[i]);
GRti %= FRtsj;
if (IsX(rep(ConstTerm(GRti)))) { // is GRti == X?
Qi = FRtsj; // If so, we found the right factor
break;
} // If this does not happen then move to the next factor of Fi
}
assert(j < FRts.length());
mappingData.rmaps[i] = Qi;
}
}
}
PAlgebraModDerived<type>::PAlgebraModDerived(const PAlgebra& _zMStar, long _r)
: zMStar(_zMStar), r(_r)
{
long p = zMStar.getP();
long m = zMStar.getM();
// For dry-run, use a tiny m value for the PAlgebra tables
if (isDryRun()) m = (p==3)? 4 : 3;
assert(r > 0);
ZZ BigPPowR = power_ZZ(p, r);
assert(BigPPowR.SinglePrecision());
pPowR = to_long(BigPPowR);
long nSlots = zMStar.getNSlots();
RBak bak; bak.save();
SetModulus(p);
// Compute the factors Ft of Phi_m(X) mod p, for all t \in T
RX phimxmod;
conv(phimxmod, zMStar.getPhimX()); // Phi_m(X) mod p
vec_RX localFactors;
EDF(localFactors, phimxmod, zMStar.getOrdP()); // equal-degree factorization
RX* first = &localFactors[0];
RX* last = first + localFactors.length();
RX* smallest = min_element(first, last);
swap(*first, *smallest);
// We make the lexicographically smallest factor have index 0.
// The remaining factors are ordered according to their representives.
RXModulus F1(localFactors[0]);
for (long i=1; i<nSlots; i++) {
unsigned long t =zMStar.ith_rep(i); // Ft is minimal polynomial of x^{1/t} mod F1
unsigned long tInv = InvMod(t, m); // tInv = t^{-1} mod m
RX X2tInv = PowerXMod(tInv,F1); // X2tInv = X^{1/t} mod F1
IrredPolyMod(localFactors[i], X2tInv, F1);
}
/* Debugging sanity-check #1: we should have Ft= GCD(F1(X^t),Phi_m(X))
for (i=1; i<nSlots; i++) {
unsigned long t = T[i];
RX X2t = PowerXMod(t,phimxmod); // X2t = X^t mod Phi_m(X)
RX Ft = GCD(CompMod(F1,X2t,phimxmod),phimxmod);
if (Ft != localFactors[i]) {
cout << "Ft != F1(X^t) mod Phi_m(X), t=" << t << endl;
exit(0);
}
}*******************************************************************/
if (r == 1) {
build(PhimXMod, phimxmod);
factors = localFactors;
pPowRContext.save();
// Compute the CRT coefficients for the Ft's
crtCoeffs.SetLength(nSlots);
for (long i=0; i<nSlots; i++) {
RX te = phimxmod / factors[i]; // \prod_{j\ne i} Fj
te %= factors[i]; // \prod_{j\ne i} Fj mod Fi
InvMod(crtCoeffs[i], te, factors[i]); // \prod_{j\ne i} Fj^{-1} mod Fi
}
}
else {
PAlgebraLift(zMStar.getPhimX(), localFactors, factors, crtCoeffs, r);
RX phimxmod1;
conv(phimxmod1, zMStar.getPhimX());
build(PhimXMod, phimxmod1);
pPowRContext.save();
}
// set factorsOverZZ
factorsOverZZ.resize(nSlots);
for (long i = 0; i < nSlots; i++)
conv(factorsOverZZ[i], factors[i]);
genCrtTable();
genMaskTable();
}
zz_pEX FrobeniusMap(const zz_pEXModulus& F)
{
return PowerXMod(zz_pE::cardinality(), F);
}
void EDF(vec_zz_pX& v, const zz_pX& f, long d)
{
EDF(v, f, PowerXMod(zz_p::modulus(), f), d);
}
void FrobeniusMap(ZZ_pEX& h, const ZZ_pEXModulus& F)
{
PowerXMod(h, ZZ_pE::cardinality(), F);
}
void SFCanZass(vec_ZZ_pX& factors, const ZZ_pX& ff, long verbose)
{
ZZ_pX f = ff;
if (!IsOne(LeadCoeff(f)))
Error("SFCanZass: bad args");
if (deg(f) == 0) {
factors.SetLength(0);
return;
}
if (deg(f) == 1) {
factors.SetLength(1);
factors[0] = f;
return;
}
factors.SetLength(0);
double t;
const ZZ& p = ZZ_p::modulus();
ZZ_pXModulus F;
build(F, f);
ZZ_pX h;
if (verbose) { cerr << "computing X^p..."; t = GetTime(); }
PowerXMod(h, p, F);
if (verbose) { cerr << (GetTime()-t) << "\n"; }
vec_pair_ZZ_pX_long u;
if (verbose) { cerr << "computing DDF..."; t = GetTime(); }
NewDDF(u, f, h, verbose);
if (verbose) {
t = GetTime()-t;
cerr << "DDF time: " << t << "\n";
}
ZZ_pX hh;
vec_ZZ_pX v;
long i;
for (i = 0; i < u.length(); i++) {
const ZZ_pX& g = u[i].a;
long d = u[i].b;
long r = deg(g)/d;
if (r == 1) {
// g is already irreducible
append(factors, g);
}
else {
// must perform EDF
if (d == 1) {
// root finding
RootEDF(v, g, verbose);
append(factors, v);
}
else {
// general case
rem(hh, h, g);
EDF(v, g, hh, d, verbose);
append(factors, v);
}
}
}
}
void SFBerlekamp(vec_ZZ_pX& factors, const ZZ_pX& ff, long verbose)
{
ZZ_pX f = ff;
if (!IsOne(LeadCoeff(f)))
Error("SFBerlekamp: bad args");
if (deg(f) == 0) {
factors.SetLength(0);
return;
}
if (deg(f) == 1) {
factors.SetLength(1);
factors[0] = f;
return;
}
double t;
const ZZ& p = ZZ_p::modulus();
long n = deg(f);
ZZ_pXModulus F;
build(F, f);
ZZ_pX g, h;
if (verbose) { cerr << "computing X^p..."; t = GetTime(); }
PowerXMod(g, p, F);
if (verbose) { cerr << (GetTime()-t) << "\n"; }
vec_long D;
long r;
vec_ZZVec M;
if (verbose) { cerr << "building matrix..."; t = GetTime(); }
BuildMatrix(M, n, g, F, verbose);
if (verbose) { cerr << (GetTime()-t) << "\n"; }
if (verbose) { cerr << "diagonalizing..."; t = GetTime(); }
NullSpace(r, D, M, verbose);
if (verbose) { cerr << (GetTime()-t) << "\n"; }
if (verbose) cerr << "number of factors = " << r << "\n";
if (r == 1) {
factors.SetLength(1);
factors[0] = f;
return;
}
if (verbose) { cerr << "factor extraction..."; t = GetTime(); }
vec_ZZ_p roots;
RandomBasisElt(g, D, M);
MinPolyMod(h, g, F, r);
if (deg(h) == r) M.kill();
FindRoots(roots, h);
FindFactors(factors, f, g, roots);
ZZ_pX g1;
vec_ZZ_pX S, S1;
long i;
while (factors.length() < r) {
if (verbose) cerr << "+";
RandomBasisElt(g, D, M);
S.kill();
for (i = 0; i < factors.length(); i++) {
const ZZ_pX& f = factors[i];
if (deg(f) == 1) {
append(S, f);
continue;
}
build(F, f);
rem(g1, g, F);
if (deg(g1) <= 0) {
append(S, f);
continue;
}
MinPolyMod(h, g1, F, min(deg(f), r-factors.length()+1));
FindRoots(roots, h);
S1.kill();
FindFactors(S1, f, g1, roots);
append(S, S1);
}
swap(factors, S);
}
if (verbose) { cerr << (GetTime()-t) << "\n"; }
if (verbose) {
cerr << "degrees:";
long i;
for (i = 0; i < factors.length(); i++)
cerr << " " << deg(factors[i]);
cerr << "\n";
}
}
long IterIrredTest(const ZZ_pX& f)
{
if (deg(f) <= 0) return 0;
if (deg(f) == 1) return 1;
ZZ_pXModulus F;
build(F, f);
ZZ_pX h;
PowerXMod(h, ZZ_p::modulus(), F);
long CompTableSize = 2*SqrRoot(deg(f));
ZZ_pXArgument H;
build(H, h, F, CompTableSize);
long i, d, limit, limit_sqr;
ZZ_pX g, X, t, prod;
SetX(X);
i = 0;
g = h;
d = 1;
limit = 2;
limit_sqr = limit*limit;
set(prod);
while (2*d <= deg(f)) {
sub(t, g, X);
MulMod(prod, prod, t, F);
i++;
if (i == limit_sqr) {
GCD(t, f, prod);
if (!IsOne(t)) return 0;
set(prod);
limit++;
limit_sqr = limit*limit;
i = 0;
}
d = d + 1;
if (2*d <= deg(f)) {
CompMod(g, g, H, F);
}
}
if (i > 0) {
GCD(t, f, prod);
if (!IsOne(t)) return 0;
}
return 1;
}