3 * Polynomial factorization (implementation).
5 * The interface function factor() at the end of this file is defined in the
6 * GiNaC namespace. All other utility functions and classes are defined in an
7 * additional anonymous namespace.
9 * Factorization starts by doing a square free factorization and making the
10 * coefficients integer. Then, depending on the number of free variables it
11 * proceeds either in dedicated univariate or multivariate factorization code.
13 * Univariate factorization does a modular factorization via Berlekamp's
14 * algorithm and distinct degree factorization. Hensel lifting is used at the
17 * Multivariate factorization uses the univariate factorization (applying a
18 * evaluation homomorphism first) and Hensel lifting raises the answer to the
19 * multivariate domain. The Hensel lifting code is completely distinct from the
20 * code used by the univariate factorization.
22 * Algorithms used can be found in
23 * [Wan] An Improved Multivariate Polynomial Factoring Algorithm,
25 * Mathematics of Computation, Vol. 32, No. 144 (1978) 1215--1231.
26 * [GCL] Algorithms for Computer Algebra,
27 * K.O.Geddes, S.R.Czapor, G.Labahn,
28 * Springer Verlag, 1992.
29 * [Mig] Some Useful Bounds,
31 * In "Computer Algebra, Symbolic and Algebraic Computation" (B.Buchberger et al., eds.),
32 * pp. 259-263, Springer-Verlag, New York, 1982.
36 * GiNaC Copyright (C) 1999-2015 Johannes Gutenberg University Mainz, Germany
38 * This program is free software; you can redistribute it and/or modify
39 * it under the terms of the GNU General Public License as published by
40 * the Free Software Foundation; either version 2 of the License, or
41 * (at your option) any later version.
43 * This program is distributed in the hope that it will be useful,
44 * but WITHOUT ANY WARRANTY; without even the implied warranty of
45 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
46 * GNU General Public License for more details.
48 * You should have received a copy of the GNU General Public License
49 * along with this program; if not, write to the Free Software
50 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
59 #include "operators.h"
62 #include "relational.h"
84 #define DCOUT(str) cout << #str << endl
85 #define DCOUTVAR(var) cout << #var << ": " << var << endl
86 #define DCOUT2(str,var) cout << #str << ": " << var << endl
87 ostream& operator<<(ostream& o, const vector<int>& v)
89 vector<int>::const_iterator i = v.begin(), end = v.end();
95 static ostream& operator<<(ostream& o, const vector<cl_I>& v)
97 vector<cl_I>::const_iterator i = v.begin(), end = v.end();
99 o << *i << "[" << i-v.begin() << "]" << " ";
104 static ostream& operator<<(ostream& o, const vector<cl_MI>& v)
106 vector<cl_MI>::const_iterator i = v.begin(), end = v.end();
108 o << *i << "[" << i-v.begin() << "]" << " ";
113 ostream& operator<<(ostream& o, const vector<numeric>& v)
115 for ( size_t i=0; i<v.size(); ++i ) {
120 ostream& operator<<(ostream& o, const vector< vector<cl_MI> >& v)
122 vector< vector<cl_MI> >::const_iterator i = v.begin(), end = v.end();
124 o << i-v.begin() << ": " << *i << endl;
131 #define DCOUTVAR(var)
132 #define DCOUT2(str,var)
133 #endif // def DEBUGFACTOR
135 // anonymous namespace to hide all utility functions
138 ////////////////////////////////////////////////////////////////////////////////
139 // modular univariate polynomial code
141 typedef std::vector<cln::cl_MI> umodpoly;
142 typedef std::vector<cln::cl_I> upoly;
143 typedef vector<umodpoly> upvec;
145 // COPY FROM UPOLY.HPP
147 // CHANGED size_t -> int !!!
148 template<typename T> static int degree(const T& p)
153 template<typename T> static typename T::value_type lcoeff(const T& p)
155 return p[p.size() - 1];
158 static bool normalize_in_field(umodpoly& a)
162 if ( lcoeff(a) == a[0].ring()->one() ) {
166 const cln::cl_MI lc_1 = recip(lcoeff(a));
167 for (std::size_t k = a.size(); k-- != 0; )
172 template<typename T> static void
173 canonicalize(T& p, const typename T::size_type hint = std::numeric_limits<typename T::size_type>::max())
178 std::size_t i = p.size() - 1;
179 // Be fast if the polynomial is already canonicalized
186 bool is_zero = false;
204 p.erase(p.begin() + i, p.end());
207 // END COPY FROM UPOLY.HPP
209 static void expt_pos(umodpoly& a, unsigned int q)
211 if ( a.empty() ) return;
212 cl_MI zero = a[0].ring()->zero();
214 a.resize(degree(a)*q+1, zero);
215 for ( int i=deg; i>0; --i ) {
221 template<bool COND, typename T = void> struct enable_if
226 template<typename T> struct enable_if<false, T> { /* empty */ };
228 template<typename T> struct uvar_poly_p
230 static const bool value = false;
233 template<> struct uvar_poly_p<upoly>
235 static const bool value = true;
238 template<> struct uvar_poly_p<umodpoly>
240 static const bool value = true;
244 // Don't define this for anything but univariate polynomials.
245 static typename enable_if<uvar_poly_p<T>::value, T>::type
246 operator+(const T& a, const T& b)
253 for ( ; i<sb; ++i ) {
256 for ( ; i<sa; ++i ) {
265 for ( ; i<sa; ++i ) {
268 for ( ; i<sb; ++i ) {
277 // Don't define this for anything but univariate polynomials. Otherwise
278 // overload resolution might fail (this actually happens when compiling
279 // GiNaC with g++ 3.4).
280 static typename enable_if<uvar_poly_p<T>::value, T>::type
281 operator-(const T& a, const T& b)
288 for ( ; i<sb; ++i ) {
291 for ( ; i<sa; ++i ) {
300 for ( ; i<sa; ++i ) {
303 for ( ; i<sb; ++i ) {
311 static upoly operator*(const upoly& a, const upoly& b)
314 if ( a.empty() || b.empty() ) return c;
316 int n = degree(a) + degree(b);
318 for ( int i=0 ; i<=n; ++i ) {
319 for ( int j=0 ; j<=i; ++j ) {
320 if ( j > degree(a) || (i-j) > degree(b) ) continue;
321 c[i] = c[i] + a[j] * b[i-j];
328 static umodpoly operator*(const umodpoly& a, const umodpoly& b)
331 if ( a.empty() || b.empty() ) return c;
333 int n = degree(a) + degree(b);
334 c.resize(n+1, a[0].ring()->zero());
335 for ( int i=0 ; i<=n; ++i ) {
336 for ( int j=0 ; j<=i; ++j ) {
337 if ( j > degree(a) || (i-j) > degree(b) ) continue;
338 c[i] = c[i] + a[j] * b[i-j];
345 static upoly operator*(const upoly& a, const cl_I& x)
352 for ( size_t i=0; i<a.size(); ++i ) {
358 static upoly operator/(const upoly& a, const cl_I& x)
365 for ( size_t i=0; i<a.size(); ++i ) {
366 r[i] = exquo(a[i],x);
371 static umodpoly operator*(const umodpoly& a, const cl_MI& x)
373 umodpoly r(a.size());
374 for ( size_t i=0; i<a.size(); ++i ) {
381 static void upoly_from_ex(upoly& up, const ex& e, const ex& x)
383 // assert: e is in Z[x]
384 int deg = e.degree(x);
386 int ldeg = e.ldegree(x);
387 for ( ; deg>=ldeg; --deg ) {
388 up[deg] = the<cl_I>(ex_to<numeric>(e.coeff(x, deg)).to_cl_N());
390 for ( ; deg>=0; --deg ) {
396 static void umodpoly_from_upoly(umodpoly& ump, const upoly& e, const cl_modint_ring& R)
400 for ( ; deg>=0; --deg ) {
401 ump[deg] = R->canonhom(e[deg]);
406 static void umodpoly_from_ex(umodpoly& ump, const ex& e, const ex& x, const cl_modint_ring& R)
408 // assert: e is in Z[x]
409 int deg = e.degree(x);
411 int ldeg = e.ldegree(x);
412 for ( ; deg>=ldeg; --deg ) {
413 cl_I coeff = the<cl_I>(ex_to<numeric>(e.coeff(x, deg)).to_cl_N());
414 ump[deg] = R->canonhom(coeff);
416 for ( ; deg>=0; --deg ) {
417 ump[deg] = R->zero();
423 static void umodpoly_from_ex(umodpoly& ump, const ex& e, const ex& x, const cl_I& modulus)
425 umodpoly_from_ex(ump, e, x, find_modint_ring(modulus));
429 static ex upoly_to_ex(const upoly& a, const ex& x)
431 if ( a.empty() ) return 0;
433 for ( int i=degree(a); i>=0; --i ) {
434 e += numeric(a[i]) * pow(x, i);
439 static ex umodpoly_to_ex(const umodpoly& a, const ex& x)
441 if ( a.empty() ) return 0;
442 cl_modint_ring R = a[0].ring();
443 cl_I mod = R->modulus;
444 cl_I halfmod = (mod-1) >> 1;
446 for ( int i=degree(a); i>=0; --i ) {
447 cl_I n = R->retract(a[i]);
449 e += numeric(n-mod) * pow(x, i);
451 e += numeric(n) * pow(x, i);
457 static upoly umodpoly_to_upoly(const umodpoly& a)
460 if ( a.empty() ) return e;
461 cl_modint_ring R = a[0].ring();
462 cl_I mod = R->modulus;
463 cl_I halfmod = (mod-1) >> 1;
464 for ( int i=degree(a); i>=0; --i ) {
465 cl_I n = R->retract(a[i]);
475 static umodpoly umodpoly_to_umodpoly(const umodpoly& a, const cl_modint_ring& R, unsigned int m)
478 if ( a.empty() ) return e;
479 cl_modint_ring oldR = a[0].ring();
480 size_t sa = a.size();
481 e.resize(sa+m, R->zero());
482 for ( size_t i=0; i<sa; ++i ) {
483 e[i+m] = R->canonhom(oldR->retract(a[i]));
489 /** Divides all coefficients of the polynomial a by the integer x.
490 * All coefficients are supposed to be divisible by x. If they are not, the
491 * the<cl_I> cast will raise an exception.
493 * @param[in,out] a polynomial of which the coefficients will be reduced by x
494 * @param[in] x integer that divides the coefficients
496 static void reduce_coeff(umodpoly& a, const cl_I& x)
498 if ( a.empty() ) return;
500 cl_modint_ring R = a[0].ring();
501 umodpoly::iterator i = a.begin(), end = a.end();
502 for ( ; i!=end; ++i ) {
503 // cln cannot perform this division in the modular field
504 cl_I c = R->retract(*i);
505 *i = cl_MI(R, the<cl_I>(c / x));
509 /** Calculates remainder of a/b.
510 * Assertion: a and b not empty.
512 * @param[in] a polynomial dividend
513 * @param[in] b polynomial divisor
514 * @param[out] r polynomial remainder
516 static void rem(const umodpoly& a, const umodpoly& b, umodpoly& r)
525 cl_MI qk = div(r[n+k], b[n]);
527 for ( int i=0; i<n; ++i ) {
528 unsigned int j = n + k - 1 - i;
529 r[j] = r[j] - qk * b[j-k];
534 fill(r.begin()+n, r.end(), a[0].ring()->zero());
538 /** Calculates quotient of a/b.
539 * Assertion: a and b not empty.
541 * @param[in] a polynomial dividend
542 * @param[in] b polynomial divisor
543 * @param[out] q polynomial quotient
545 static void div(const umodpoly& a, const umodpoly& b, umodpoly& q)
554 q.resize(k+1, a[0].ring()->zero());
556 cl_MI qk = div(r[n+k], b[n]);
559 for ( int i=0; i<n; ++i ) {
560 unsigned int j = n + k - 1 - i;
561 r[j] = r[j] - qk * b[j-k];
569 /** Calculates quotient and remainder of a/b.
570 * Assertion: a and b not empty.
572 * @param[in] a polynomial dividend
573 * @param[in] b polynomial divisor
574 * @param[out] r polynomial remainder
575 * @param[out] q polynomial quotient
577 static void remdiv(const umodpoly& a, const umodpoly& b, umodpoly& r, umodpoly& q)
586 q.resize(k+1, a[0].ring()->zero());
588 cl_MI qk = div(r[n+k], b[n]);
591 for ( int i=0; i<n; ++i ) {
592 unsigned int j = n + k - 1 - i;
593 r[j] = r[j] - qk * b[j-k];
598 fill(r.begin()+n, r.end(), a[0].ring()->zero());
603 /** Calculates the GCD of polynomial a and b.
605 * @param[in] a polynomial
606 * @param[in] b polynomial
609 static void gcd(const umodpoly& a, const umodpoly& b, umodpoly& c)
611 if ( degree(a) < degree(b) ) return gcd(b, a, c);
614 normalize_in_field(c);
616 normalize_in_field(d);
618 while ( !d.empty() ) {
623 normalize_in_field(c);
626 /** Calculates the derivative of the polynomial a.
628 * @param[in] a polynomial of which to take the derivative
629 * @param[out] d result/derivative
631 static void deriv(const umodpoly& a, umodpoly& d)
634 if ( a.size() <= 1 ) return;
636 d.insert(d.begin(), a.begin()+1, a.end());
638 for ( int i=1; i<max; ++i ) {
644 static bool unequal_one(const umodpoly& a)
646 if ( a.empty() ) return true;
647 return ( a.size() != 1 || a[0] != a[0].ring()->one() );
650 static bool equal_one(const umodpoly& a)
652 return ( a.size() == 1 && a[0] == a[0].ring()->one() );
655 /** Returns true if polynomial a is square free.
657 * @param[in] a polynomial to check
658 * @return true if polynomial is square free, false otherwise
660 static bool squarefree(const umodpoly& a)
672 // END modular univariate polynomial code
673 ////////////////////////////////////////////////////////////////////////////////
675 ////////////////////////////////////////////////////////////////////////////////
678 typedef vector<cl_MI> mvec;
682 friend ostream& operator<<(ostream& o, const modular_matrix& m);
684 modular_matrix(size_t r_, size_t c_, const cl_MI& init) : r(r_), c(c_)
688 size_t rowsize() const { return r; }
689 size_t colsize() const { return c; }
690 cl_MI& operator()(size_t row, size_t col) { return m[row*c + col]; }
691 cl_MI operator()(size_t row, size_t col) const { return m[row*c + col]; }
692 void mul_col(size_t col, const cl_MI x)
694 for ( size_t rc=0; rc<r; ++rc ) {
695 std::size_t i = c*rc + col;
699 void sub_col(size_t col1, size_t col2, const cl_MI fac)
701 for ( size_t rc=0; rc<r; ++rc ) {
702 std::size_t i1 = col1 + c*rc;
703 std::size_t i2 = col2 + c*rc;
704 m[i1] = m[i1] - m[i2]*fac;
707 void switch_col(size_t col1, size_t col2)
709 for ( size_t rc=0; rc<r; ++rc ) {
710 std::size_t i1 = col1 + rc*c;
711 std::size_t i2 = col2 + rc*c;
712 std::swap(m[i1], m[i2]);
715 void mul_row(size_t row, const cl_MI x)
717 for ( size_t cc=0; cc<c; ++cc ) {
718 std::size_t i = row*c + cc;
722 void sub_row(size_t row1, size_t row2, const cl_MI fac)
724 for ( size_t cc=0; cc<c; ++cc ) {
725 std::size_t i1 = row1*c + cc;
726 std::size_t i2 = row2*c + cc;
727 m[i1] = m[i1] - m[i2]*fac;
730 void switch_row(size_t row1, size_t row2)
732 for ( size_t cc=0; cc<c; ++cc ) {
733 std::size_t i1 = row1*c + cc;
734 std::size_t i2 = row2*c + cc;
735 std::swap(m[i1], m[i2]);
738 bool is_col_zero(size_t col) const
740 for ( size_t rr=0; rr<r; ++rr ) {
741 std::size_t i = col + rr*c;
742 if ( !zerop(m[i]) ) {
748 bool is_row_zero(size_t row) const
750 for ( size_t cc=0; cc<c; ++cc ) {
751 std::size_t i = row*c + cc;
752 if ( !zerop(m[i]) ) {
758 void set_row(size_t row, const vector<cl_MI>& newrow)
760 for (std::size_t i2 = 0; i2 < newrow.size(); ++i2) {
761 std::size_t i1 = row*c + i2;
765 mvec::const_iterator row_begin(size_t row) const { return m.begin()+row*c; }
766 mvec::const_iterator row_end(size_t row) const { return m.begin()+row*c+r; }
773 modular_matrix operator*(const modular_matrix& m1, const modular_matrix& m2)
775 const unsigned int r = m1.rowsize();
776 const unsigned int c = m2.colsize();
777 modular_matrix o(r,c,m1(0,0));
779 for ( size_t i=0; i<r; ++i ) {
780 for ( size_t j=0; j<c; ++j ) {
782 buf = m1(i,0) * m2(0,j);
783 for ( size_t k=1; k<c; ++k ) {
784 buf = buf + m1(i,k)*m2(k,j);
792 ostream& operator<<(ostream& o, const modular_matrix& m)
794 cl_modint_ring R = m(0,0).ring();
796 for ( size_t i=0; i<m.rowsize(); ++i ) {
798 for ( size_t j=0; j<m.colsize()-1; ++j ) {
799 o << R->retract(m(i,j)) << ",";
801 o << R->retract(m(i,m.colsize()-1)) << "}";
802 if ( i != m.rowsize()-1 ) {
809 #endif // def DEBUGFACTOR
811 // END modular matrix
812 ////////////////////////////////////////////////////////////////////////////////
814 /** Calculates the Q matrix for a polynomial. Used by Berlekamp's algorithm.
816 * @param[in] a_ modular polynomial
817 * @param[out] Q Q matrix
819 static void q_matrix(const umodpoly& a_, modular_matrix& Q)
822 normalize_in_field(a);
825 unsigned int q = cl_I_to_uint(a[0].ring()->modulus);
826 umodpoly r(n, a[0].ring()->zero());
827 r[0] = a[0].ring()->one();
829 unsigned int max = (n-1) * q;
830 for ( size_t m=1; m<=max; ++m ) {
831 cl_MI rn_1 = r.back();
832 for ( size_t i=n-1; i>0; --i ) {
833 r[i] = r[i-1] - (rn_1 * a[i]);
836 if ( (m % q) == 0 ) {
842 /** Determine the nullspace of a matrix M-1.
844 * @param[in,out] M matrix, will be modified
845 * @param[out] basis calculated nullspace of M-1
847 static void nullspace(modular_matrix& M, vector<mvec>& basis)
849 const size_t n = M.rowsize();
850 const cl_MI one = M(0,0).ring()->one();
851 for ( size_t i=0; i<n; ++i ) {
852 M(i,i) = M(i,i) - one;
854 for ( size_t r=0; r<n; ++r ) {
856 for ( ; cc<n; ++cc ) {
857 if ( !zerop(M(r,cc)) ) {
859 if ( !zerop(M(cc,cc)) ) {
871 M.mul_col(r, recip(M(r,r)));
872 for ( cc=0; cc<n; ++cc ) {
874 M.sub_col(cc, r, M(r,cc));
880 for ( size_t i=0; i<n; ++i ) {
881 M(i,i) = M(i,i) - one;
883 for ( size_t i=0; i<n; ++i ) {
884 if ( !M.is_row_zero(i) ) {
885 mvec nu(M.row_begin(i), M.row_end(i));
891 /** Berlekamp's modular factorization.
893 * The implementation follows the algorithm in chapter 8 of [GCL].
895 * @param[in] a modular polynomial
896 * @param[out] upv vector containing modular factors. if upv was not empty the
897 * new elements are added at the end
899 static void berlekamp(const umodpoly& a, upvec& upv)
901 cl_modint_ring R = a[0].ring();
902 umodpoly one(1, R->one());
904 // find nullspace of Q matrix
905 modular_matrix Q(degree(a), degree(a), R->zero());
910 const unsigned int k = nu.size();
916 list<umodpoly> factors;
917 factors.push_back(a);
918 unsigned int size = 1;
920 unsigned int q = cl_I_to_uint(R->modulus);
922 list<umodpoly>::iterator u = factors.begin();
924 // calculate all gcd's
926 for ( unsigned int s=0; s<q; ++s ) {
927 umodpoly nur = nu[r];
928 nur[0] = nur[0] - cl_MI(R, s);
932 if ( unequal_one(g) && g != *u ) {
935 if ( equal_one(uo) ) {
936 throw logic_error("berlekamp: unexpected divisor.");
941 factors.push_back(g);
943 list<umodpoly>::const_iterator i = factors.begin(), end = factors.end();
945 if ( degree(*i) ) ++size;
949 list<umodpoly>::const_iterator i = factors.begin(), end = factors.end();
964 // modular square free factorization is not used at the moment so we deactivate
968 /** Calculates a^(1/prime).
970 * @param[in] a polynomial
971 * @param[in] prime prime number -> exponent 1/prime
972 * @param[in] ap resulting polynomial
974 static void expt_1_over_p(const umodpoly& a, unsigned int prime, umodpoly& ap)
976 size_t newdeg = degree(a)/prime;
979 for ( size_t i=1; i<=newdeg; ++i ) {
984 /** Modular square free factorization.
986 * @param[in] a polynomial
987 * @param[out] factors modular factors
988 * @param[out] mult corresponding multiplicities (exponents)
990 static void modsqrfree(const umodpoly& a, upvec& factors, vector<int>& mult)
992 const unsigned int prime = cl_I_to_uint(a[0].ring()->modulus);
1001 while ( unequal_one(w) ) {
1006 factors.push_back(z);
1014 if ( unequal_one(c) ) {
1016 expt_1_over_p(c, prime, cp);
1017 size_t previ = mult.size();
1018 modsqrfree(cp, factors, mult);
1019 for ( size_t i=previ; i<mult.size(); ++i ) {
1026 expt_1_over_p(a, prime, ap);
1027 size_t previ = mult.size();
1028 modsqrfree(ap, factors, mult);
1029 for ( size_t i=previ; i<mult.size(); ++i ) {
1035 #endif // deactivation of square free factorization
1037 /** Distinct degree factorization (DDF).
1039 * The implementation follows the algorithm in chapter 8 of [GCL].
1041 * @param[in] a_ modular polynomial
1042 * @param[out] degrees vector containing the degrees of the factors of the
1043 * corresponding polynomials in ddfactors.
1044 * @param[out] ddfactors vector containing polynomials which factors have the
1045 * degree given in degrees.
1047 static void distinct_degree_factor(const umodpoly& a_, vector<int>& degrees, upvec& ddfactors)
1051 cl_modint_ring R = a[0].ring();
1052 int q = cl_I_to_int(R->modulus);
1053 int nhalf = degree(a)/2;
1061 while ( i <= nhalf ) {
1066 umodpoly wx = w - x;
1068 if ( unequal_one(buf) ) {
1069 degrees.push_back(i);
1070 ddfactors.push_back(buf);
1072 if ( unequal_one(buf) ) {
1076 nhalf = degree(a)/2;
1082 if ( unequal_one(a) ) {
1083 degrees.push_back(degree(a));
1084 ddfactors.push_back(a);
1088 /** Modular same degree factorization.
1089 * Same degree factorization is a kind of misnomer. It performs distinct degree
1090 * factorization, but instead of using the Cantor-Zassenhaus algorithm it
1091 * (sub-optimally) uses Berlekamp's algorithm for the factors of the same
1094 * @param[in] a modular polynomial
1095 * @param[out] upv vector containing modular factors. if upv was not empty the
1096 * new elements are added at the end
1098 static void same_degree_factor(const umodpoly& a, upvec& upv)
1100 cl_modint_ring R = a[0].ring();
1102 vector<int> degrees;
1104 distinct_degree_factor(a, degrees, ddfactors);
1106 for ( size_t i=0; i<degrees.size(); ++i ) {
1107 if ( degrees[i] == degree(ddfactors[i]) ) {
1108 upv.push_back(ddfactors[i]);
1111 berlekamp(ddfactors[i], upv);
1116 // Yes, we can (choose).
1117 #define USE_SAME_DEGREE_FACTOR
1119 /** Modular univariate factorization.
1121 * In principle, we have two algorithms at our disposal: Berlekamp's algorithm
1122 * and same degree factorization (SDF). SDF seems to be slightly faster in
1123 * almost all cases so it is activated as default.
1125 * @param[in] p modular polynomial
1126 * @param[out] upv vector containing modular factors. if upv was not empty the
1127 * new elements are added at the end
1129 static void factor_modular(const umodpoly& p, upvec& upv)
1131 #ifdef USE_SAME_DEGREE_FACTOR
1132 same_degree_factor(p, upv);
1138 /** Calculates modular polynomials s and t such that a*s+b*t==1.
1139 * Assertion: a and b are relatively prime and not zero.
1141 * @param[in] a polynomial
1142 * @param[in] b polynomial
1143 * @param[out] s polynomial
1144 * @param[out] t polynomial
1146 static void exteuclid(const umodpoly& a, const umodpoly& b, umodpoly& s, umodpoly& t)
1148 if ( degree(a) < degree(b) ) {
1149 exteuclid(b, a, t, s);
1153 umodpoly one(1, a[0].ring()->one());
1154 umodpoly c = a; normalize_in_field(c);
1155 umodpoly d = b; normalize_in_field(d);
1163 umodpoly r = c - q * d;
1164 umodpoly r1 = s - q * d1;
1165 umodpoly r2 = t - q * d2;
1169 if ( r.empty() ) break;
1174 cl_MI fac = recip(lcoeff(a) * lcoeff(c));
1175 umodpoly::iterator i = s.begin(), end = s.end();
1176 for ( ; i!=end; ++i ) {
1180 fac = recip(lcoeff(b) * lcoeff(c));
1181 i = t.begin(), end = t.end();
1182 for ( ; i!=end; ++i ) {
1188 /** Replaces the leading coefficient in a polynomial by a given number.
1190 * @param[in] poly polynomial to change
1191 * @param[in] lc new leading coefficient
1192 * @return changed polynomial
1194 static upoly replace_lc(const upoly& poly, const cl_I& lc)
1196 if ( poly.empty() ) return poly;
1202 /** Calculates the bound for the modulus.
1205 static inline cl_I calc_bound(const ex& a, const ex& x, int maxdeg)
1209 for ( int i=a.degree(x); i>=a.ldegree(x); --i ) {
1210 cl_I aa = abs(the<cl_I>(ex_to<numeric>(a.coeff(x, i)).to_cl_N()));
1211 if ( aa > maxcoeff ) maxcoeff = aa;
1212 coeff = coeff + square(aa);
1214 cl_I coeffnorm = ceiling1(the<cl_R>(cln::sqrt(coeff)));
1215 cl_I B = coeffnorm * expt_pos(cl_I(2), cl_I(maxdeg));
1216 return ( B > maxcoeff ) ? B : maxcoeff;
1219 /** Calculates the bound for the modulus.
1222 static inline cl_I calc_bound(const upoly& a, int maxdeg)
1226 for ( int i=degree(a); i>=0; --i ) {
1227 cl_I aa = abs(a[i]);
1228 if ( aa > maxcoeff ) maxcoeff = aa;
1229 coeff = coeff + square(aa);
1231 cl_I coeffnorm = ceiling1(the<cl_R>(cln::sqrt(coeff)));
1232 cl_I B = coeffnorm * expt_pos(cl_I(2), cl_I(maxdeg));
1233 return ( B > maxcoeff ) ? B : maxcoeff;
1236 /** Hensel lifting as used by factor_univariate().
1238 * The implementation follows the algorithm in chapter 6 of [GCL].
1240 * @param[in] a_ primitive univariate polynomials
1241 * @param[in] p prime number that does not divide lcoeff(a)
1242 * @param[in] u1_ modular factor of a (mod p)
1243 * @param[in] w1_ modular factor of a (mod p), relatively prime to u1_,
1244 * fulfilling u1_*w1_ == a mod p
1245 * @param[out] u lifted factor
1246 * @param[out] w lifted factor, u*w = a
1248 static void hensel_univar(const upoly& a_, unsigned int p, const umodpoly& u1_, const umodpoly& w1_, upoly& u, upoly& w)
1251 const cl_modint_ring& R = u1_[0].ring();
1254 int maxdeg = (degree(u1_) > degree(w1_)) ? degree(u1_) : degree(w1_);
1255 cl_I maxmodulus = 2*calc_bound(a, maxdeg);
1258 cl_I alpha = lcoeff(a);
1261 normalize_in_field(nu1);
1263 normalize_in_field(nw1);
1265 phi = umodpoly_to_upoly(nu1) * alpha;
1267 umodpoly_from_upoly(u1, phi, R);
1268 phi = umodpoly_to_upoly(nw1) * alpha;
1270 umodpoly_from_upoly(w1, phi, R);
1275 exteuclid(u1, w1, s, t);
1278 u = replace_lc(umodpoly_to_upoly(u1), alpha);
1279 w = replace_lc(umodpoly_to_upoly(w1), alpha);
1280 upoly e = a - u * w;
1284 while ( !e.empty() && modulus < maxmodulus ) {
1285 upoly c = e / modulus;
1286 phi = umodpoly_to_upoly(s) * c;
1287 umodpoly sigmatilde;
1288 umodpoly_from_upoly(sigmatilde, phi, R);
1289 phi = umodpoly_to_upoly(t) * c;
1291 umodpoly_from_upoly(tautilde, phi, R);
1293 remdiv(sigmatilde, w1, r, q);
1295 phi = umodpoly_to_upoly(tautilde) + umodpoly_to_upoly(q) * umodpoly_to_upoly(u1);
1297 umodpoly_from_upoly(tau, phi, R);
1298 u = u + umodpoly_to_upoly(tau) * modulus;
1299 w = w + umodpoly_to_upoly(sigma) * modulus;
1301 modulus = modulus * p;
1307 for ( size_t i=1; i<u.size(); ++i ) {
1309 if ( g == 1 ) break;
1324 /** Returns a new prime number.
1326 * @param[in] p prime number
1327 * @return next prime number after p
1329 static unsigned int next_prime(unsigned int p)
1331 static vector<unsigned int> primes;
1332 if ( primes.size() == 0 ) {
1333 primes.push_back(3); primes.push_back(5); primes.push_back(7);
1335 vector<unsigned int>::const_iterator it = primes.begin();
1336 if ( p >= primes.back() ) {
1337 unsigned int candidate = primes.back() + 2;
1339 size_t n = primes.size()/2;
1340 for ( size_t i=0; i<n; ++i ) {
1341 if ( candidate % primes[i] ) continue;
1345 primes.push_back(candidate);
1346 if ( candidate > p ) break;
1350 vector<unsigned int>::const_iterator end = primes.end();
1351 for ( ; it!=end; ++it ) {
1356 throw logic_error("next_prime: should not reach this point!");
1359 /** Manages the splitting a vector of of modular factors into two partitions.
1361 class factor_partition
1364 /** Takes the vector of modular factors and initializes the first partition */
1365 factor_partition(const upvec& factors_) : factors(factors_)
1371 one.resize(1, factors.front()[0].ring()->one());
1376 int operator[](size_t i) const { return k[i]; }
1377 size_t size() const { return n; }
1378 size_t size_left() const { return n-len; }
1379 size_t size_right() const { return len; }
1380 /** Initializes the next partition.
1381 Returns true, if there is one, false otherwise. */
1384 if ( last == n-1 ) {
1394 while ( k[last] == 0 ) { --last; }
1395 if ( last == 0 && n == 2*len ) return false;
1397 for ( size_t i=0; i<=len-rem; ++i ) {
1401 fill(k.begin()+last, k.end(), 0);
1408 if ( len > n/2 ) return false;
1409 fill(k.begin(), k.begin()+len, 1);
1410 fill(k.begin()+len+1, k.end(), 0);
1419 /** Get first partition */
1420 umodpoly& left() { return lr[0]; }
1421 /** Get second partition */
1422 umodpoly& right() { return lr[1]; }
1431 while ( i < n && k[i] == group ) { ++d; ++i; }
1433 if ( cache[pos].size() >= d ) {
1434 lr[group] = lr[group] * cache[pos][d-1];
1437 if ( cache[pos].size() == 0 ) {
1438 cache[pos].push_back(factors[pos] * factors[pos+1]);
1440 size_t j = pos + cache[pos].size() + 1;
1441 d -= cache[pos].size();
1443 umodpoly buf = cache[pos].back() * factors[j];
1444 cache[pos].push_back(buf);
1448 lr[group] = lr[group] * cache[pos].back();
1452 lr[group] = lr[group] * factors[pos];
1464 for ( size_t i=0; i<n; ++i ) {
1465 lr[k[i]] = lr[k[i]] * factors[i];
1471 vector< vector<umodpoly> > cache;
1480 /** Contains a pair of univariate polynomial and its modular factors.
1481 * Used by factor_univariate().
1489 /** Univariate polynomial factorization.
1491 * Modular factorization is tried for several primes to minimize the number of
1492 * modular factors. Then, Hensel lifting is performed.
1494 * @param[in] poly expanded square free univariate polynomial
1495 * @param[in] x symbol
1496 * @param[in,out] prime prime number to start trying modular factorization with,
1497 * output value is the prime number actually used
1499 static ex factor_univariate(const ex& poly, const ex& x, unsigned int& prime)
1501 ex unit, cont, prim_ex;
1502 poly.unitcontprim(x, unit, cont, prim_ex);
1504 upoly_from_ex(prim, prim_ex, x);
1506 // determine proper prime and minimize number of modular factors
1508 unsigned int lastp = prime;
1510 unsigned int trials = 0;
1511 unsigned int minfactors = 0;
1513 const numeric& cont_n = ex_to<numeric>(cont);
1515 if (cont_n.is_integer()) {
1516 i_cont = the<cl_I>(cont_n.to_cl_N());
1518 // poly \in Q[x] => poly = q ipoly, ipoly \in Z[x], q \in Q
1519 // factor(poly) \equiv q factor(ipoly)
1522 cl_I lc = lcoeff(prim)*i_cont;
1524 while ( trials < 2 ) {
1527 prime = next_prime(prime);
1528 if ( !zerop(rem(lc, prime)) ) {
1529 R = find_modint_ring(prime);
1530 umodpoly_from_upoly(modpoly, prim, R);
1531 if ( squarefree(modpoly) ) break;
1535 // do modular factorization
1537 factor_modular(modpoly, trialfactors);
1538 if ( trialfactors.size() <= 1 ) {
1539 // irreducible for sure
1543 if ( minfactors == 0 || trialfactors.size() < minfactors ) {
1544 factors = trialfactors;
1545 minfactors = trialfactors.size();
1554 R = find_modint_ring(prime);
1556 // lift all factor combinations
1557 stack<ModFactors> tocheck;
1560 mf.factors = factors;
1564 while ( tocheck.size() ) {
1565 const size_t n = tocheck.top().factors.size();
1566 factor_partition part(tocheck.top().factors);
1568 // call Hensel lifting
1569 hensel_univar(tocheck.top().poly, prime, part.left(), part.right(), f1, f2);
1570 if ( !f1.empty() ) {
1571 // successful, update the stack and the result
1572 if ( part.size_left() == 1 ) {
1573 if ( part.size_right() == 1 ) {
1574 result *= upoly_to_ex(f1, x) * upoly_to_ex(f2, x);
1578 result *= upoly_to_ex(f1, x);
1579 tocheck.top().poly = f2;
1580 for ( size_t i=0; i<n; ++i ) {
1581 if ( part[i] == 0 ) {
1582 tocheck.top().factors.erase(tocheck.top().factors.begin()+i);
1588 else if ( part.size_right() == 1 ) {
1589 if ( part.size_left() == 1 ) {
1590 result *= upoly_to_ex(f1, x) * upoly_to_ex(f2, x);
1594 result *= upoly_to_ex(f2, x);
1595 tocheck.top().poly = f1;
1596 for ( size_t i=0; i<n; ++i ) {
1597 if ( part[i] == 1 ) {
1598 tocheck.top().factors.erase(tocheck.top().factors.begin()+i);
1605 upvec newfactors1(part.size_left()), newfactors2(part.size_right());
1606 upvec::iterator i1 = newfactors1.begin(), i2 = newfactors2.begin();
1607 for ( size_t i=0; i<n; ++i ) {
1609 *i2++ = tocheck.top().factors[i];
1612 *i1++ = tocheck.top().factors[i];
1615 tocheck.top().factors = newfactors1;
1616 tocheck.top().poly = f1;
1618 mf.factors = newfactors2;
1626 if ( !part.next() ) {
1627 // if no more combinations left, return polynomial as
1629 result *= upoly_to_ex(tocheck.top().poly, x);
1637 return unit * cont * result;
1640 /** Second interface to factor_univariate() to be used if the information about
1641 * the prime is not needed.
1643 static inline ex factor_univariate(const ex& poly, const ex& x)
1646 return factor_univariate(poly, x, prime);
1649 /** Represents an evaluation point (<symbol>==<integer>).
1658 ostream& operator<<(ostream& o, const vector<EvalPoint>& v)
1660 for ( size_t i=0; i<v.size(); ++i ) {
1661 o << "(" << v[i].x << "==" << v[i].evalpoint << ") ";
1665 #endif // def DEBUGFACTOR
1667 // forward declaration
1668 static vector<ex> multivar_diophant(const vector<ex>& a_, const ex& x, const ex& c, const vector<EvalPoint>& I, unsigned int d, unsigned int p, unsigned int k);
1670 /** Utility function for multivariate Hensel lifting.
1672 * Solves the equation
1673 * s_1*b_1 + ... + s_r*b_r == 1 mod p^k
1674 * with deg(s_i) < deg(a_i)
1675 * and with given b_1 = a_1 * ... * a_{i-1} * a_{i+1} * ... * a_r
1677 * The implementation follows the algorithm in chapter 6 of [GCL].
1679 * @param[in] a vector of modular univariate polynomials
1680 * @param[in] x symbol
1681 * @param[in] p prime number
1682 * @param[in] k p^k is modulus
1683 * @return vector of polynomials (s_i)
1685 static upvec multiterm_eea_lift(const upvec& a, const ex& x, unsigned int p, unsigned int k)
1687 const size_t r = a.size();
1688 cl_modint_ring R = find_modint_ring(expt_pos(cl_I(p),k));
1691 for ( size_t j=r-2; j>=1; --j ) {
1692 q[j-1] = a[j] * q[j];
1694 umodpoly beta(1, R->one());
1696 for ( size_t j=1; j<r; ++j ) {
1697 vector<ex> mdarg(2);
1698 mdarg[0] = umodpoly_to_ex(q[j-1], x);
1699 mdarg[1] = umodpoly_to_ex(a[j-1], x);
1700 vector<EvalPoint> empty;
1701 vector<ex> exsigma = multivar_diophant(mdarg, x, umodpoly_to_ex(beta, x), empty, 0, p, k);
1703 umodpoly_from_ex(sigma1, exsigma[0], x, R);
1705 umodpoly_from_ex(sigma2, exsigma[1], x, R);
1707 s.push_back(sigma2);
1713 /** Changes the modulus of a modular polynomial. Used by eea_lift().
1715 * @param[in] R new modular ring
1716 * @param[in,out] a polynomial to change (in situ)
1718 static void change_modulus(const cl_modint_ring& R, umodpoly& a)
1720 if ( a.empty() ) return;
1721 cl_modint_ring oldR = a[0].ring();
1722 umodpoly::iterator i = a.begin(), end = a.end();
1723 for ( ; i!=end; ++i ) {
1724 *i = R->canonhom(oldR->retract(*i));
1729 /** Utility function for multivariate Hensel lifting.
1731 * Solves s*a + t*b == 1 mod p^k given a,b.
1733 * The implementation follows the algorithm in chapter 6 of [GCL].
1735 * @param[in] a polynomial
1736 * @param[in] b polynomial
1737 * @param[in] x symbol
1738 * @param[in] p prime number
1739 * @param[in] k p^k is modulus
1740 * @param[out] s_ output polynomial
1741 * @param[out] t_ output polynomial
1743 static void eea_lift(const umodpoly& a, const umodpoly& b, const ex& x, unsigned int p, unsigned int k, umodpoly& s_, umodpoly& t_)
1745 cl_modint_ring R = find_modint_ring(p);
1747 change_modulus(R, amod);
1749 change_modulus(R, bmod);
1753 exteuclid(amod, bmod, smod, tmod);
1755 cl_modint_ring Rpk = find_modint_ring(expt_pos(cl_I(p),k));
1757 change_modulus(Rpk, s);
1759 change_modulus(Rpk, t);
1762 umodpoly one(1, Rpk->one());
1763 for ( size_t j=1; j<k; ++j ) {
1764 umodpoly e = one - a * s - b * t;
1765 reduce_coeff(e, modulus);
1767 change_modulus(R, c);
1768 umodpoly sigmabar = smod * c;
1769 umodpoly taubar = tmod * c;
1771 remdiv(sigmabar, bmod, sigma, q);
1772 umodpoly tau = taubar + q * amod;
1773 umodpoly sadd = sigma;
1774 change_modulus(Rpk, sadd);
1775 cl_MI modmodulus(Rpk, modulus);
1776 s = s + sadd * modmodulus;
1777 umodpoly tadd = tau;
1778 change_modulus(Rpk, tadd);
1779 t = t + tadd * modmodulus;
1780 modulus = modulus * p;
1786 /** Utility function for multivariate Hensel lifting.
1788 * Solves the equation
1789 * s_1*b_1 + ... + s_r*b_r == x^m mod p^k
1790 * with given b_1 = a_1 * ... * a_{i-1} * a_{i+1} * ... * a_r
1792 * The implementation follows the algorithm in chapter 6 of [GCL].
1794 * @param a vector with univariate polynomials mod p^k
1796 * @param m exponent of x^m in the equation to solve
1797 * @param p prime number
1798 * @param k p^k is modulus
1799 * @return vector of polynomials (s_i)
1801 static upvec univar_diophant(const upvec& a, const ex& x, unsigned int m, unsigned int p, unsigned int k)
1803 cl_modint_ring R = find_modint_ring(expt_pos(cl_I(p),k));
1805 const size_t r = a.size();
1808 upvec s = multiterm_eea_lift(a, x, p, k);
1809 for ( size_t j=0; j<r; ++j ) {
1810 umodpoly bmod = umodpoly_to_umodpoly(s[j], R, m);
1812 rem(bmod, a[j], buf);
1813 result.push_back(buf);
1818 eea_lift(a[1], a[0], x, p, k, s, t);
1819 umodpoly bmod = umodpoly_to_umodpoly(s, R, m);
1821 remdiv(bmod, a[0], buf, q);
1822 result.push_back(buf);
1823 umodpoly t1mod = umodpoly_to_umodpoly(t, R, m);
1824 buf = t1mod + q * a[1];
1825 result.push_back(buf);
1831 /** Map used by function make_modular().
1832 * Finds every coefficient in a polynomial and replaces it by is value in the
1833 * given modular ring R (symmetric representation).
1835 struct make_modular_map : public map_function {
1837 make_modular_map(const cl_modint_ring& R_) : R(R_) { }
1838 ex operator()(const ex& e)
1840 if ( is_a<add>(e) || is_a<mul>(e) ) {
1841 return e.map(*this);
1843 else if ( is_a<numeric>(e) ) {
1844 numeric mod(R->modulus);
1845 numeric halfmod = (mod-1)/2;
1846 cl_MI emod = R->canonhom(the<cl_I>(ex_to<numeric>(e).to_cl_N()));
1847 numeric n(R->retract(emod));
1848 if ( n > halfmod ) {
1859 /** Helps mimicking modular multivariate polynomial arithmetic.
1861 * @param e expression of which to make the coefficients equal to their value
1862 * in the modular ring R (symmetric representation)
1863 * @param R modular ring
1864 * @return resulting expression
1866 static ex make_modular(const ex& e, const cl_modint_ring& R)
1868 make_modular_map map(R);
1869 return map(e.expand());
1872 /** Utility function for multivariate Hensel lifting.
1874 * Returns the polynomials s_i that fulfill
1875 * s_1*b_1 + ... + s_r*b_r == c mod <I^(d+1),p^k>
1876 * with given b_1 = a_1 * ... * a_{i-1} * a_{i+1} * ... * a_r
1878 * The implementation follows the algorithm in chapter 6 of [GCL].
1880 * @param a_ vector of multivariate factors mod p^k
1881 * @param x symbol (equiv. x_1 in [GCL])
1882 * @param c polynomial mod p^k
1883 * @param I vector of evaluation points
1884 * @param d maximum total degree of result
1885 * @param p prime number
1886 * @param k p^k is modulus
1887 * @return vector of polynomials (s_i)
1889 static vector<ex> multivar_diophant(const vector<ex>& a_, const ex& x, const ex& c, const vector<EvalPoint>& I,
1890 unsigned int d, unsigned int p, unsigned int k)
1894 const cl_modint_ring R = find_modint_ring(expt_pos(cl_I(p),k));
1895 const size_t r = a.size();
1896 const size_t nu = I.size() + 1;
1900 ex xnu = I.back().x;
1901 int alphanu = I.back().evalpoint;
1904 for ( size_t i=0; i<r; ++i ) {
1908 for ( size_t i=0; i<r; ++i ) {
1909 b[i] = normal(A / a[i]);
1912 vector<ex> anew = a;
1913 for ( size_t i=0; i<r; ++i ) {
1914 anew[i] = anew[i].subs(xnu == alphanu);
1916 ex cnew = c.subs(xnu == alphanu);
1917 vector<EvalPoint> Inew = I;
1919 sigma = multivar_diophant(anew, x, cnew, Inew, d, p, k);
1922 for ( size_t i=0; i<r; ++i ) {
1923 buf -= sigma[i] * b[i];
1925 ex e = make_modular(buf, R);
1928 for ( size_t m=1; !e.is_zero() && e.has(xnu) && m<=d; ++m ) {
1929 monomial *= (xnu - alphanu);
1930 monomial = expand(monomial);
1931 ex cm = e.diff(ex_to<symbol>(xnu), m).subs(xnu==alphanu) / factorial(m);
1932 cm = make_modular(cm, R);
1933 if ( !cm.is_zero() ) {
1934 vector<ex> delta_s = multivar_diophant(anew, x, cm, Inew, d, p, k);
1936 for ( size_t j=0; j<delta_s.size(); ++j ) {
1937 delta_s[j] *= monomial;
1938 sigma[j] += delta_s[j];
1939 buf -= delta_s[j] * b[j];
1941 e = make_modular(buf, R);
1947 for ( size_t i=0; i<a.size(); ++i ) {
1949 umodpoly_from_ex(up, a[i], x, R);
1953 sigma.insert(sigma.begin(), r, 0);
1956 if ( is_a<add>(c) ) {
1964 for ( size_t i=0; i<nterms; ++i ) {
1965 int m = z.degree(x);
1966 cl_I cm = the<cl_I>(ex_to<numeric>(z.lcoeff(x)).to_cl_N());
1967 upvec delta_s = univar_diophant(amod, x, m, p, k);
1970 while ( poscm < 0 ) {
1971 poscm = poscm + expt_pos(cl_I(p),k);
1973 modcm = cl_MI(R, poscm);
1974 for ( size_t j=0; j<delta_s.size(); ++j ) {
1975 delta_s[j] = delta_s[j] * modcm;
1976 sigma[j] = sigma[j] + umodpoly_to_ex(delta_s[j], x);
1984 for ( size_t i=0; i<sigma.size(); ++i ) {
1985 sigma[i] = make_modular(sigma[i], R);
1991 /** Multivariate Hensel lifting.
1992 * The implementation follows the algorithm in chapter 6 of [GCL].
1993 * Since we don't have a data type for modular multivariate polynomials, the
1994 * respective operations are done in a GiNaC::ex and the function
1995 * make_modular() is then called to make the coefficient modular p^l.
1997 * @param a multivariate polynomial primitive in x
1998 * @param x symbol (equiv. x_1 in [GCL])
1999 * @param I vector of evaluation points (x_2==a_2,x_3==a_3,...)
2000 * @param p prime number (should not divide lcoeff(a mod I))
2001 * @param l p^l is the modulus of the lifted univariate field
2002 * @param u vector of modular (mod p^l) factors of a mod I
2003 * @param lcU correct leading coefficient of the univariate factors of a mod I
2004 * @return list GiNaC::lst with lifted factors (multivariate factors of a),
2005 * empty if Hensel lifting did not succeed
2007 static ex hensel_multivar(const ex& a, const ex& x, const vector<EvalPoint>& I,
2008 unsigned int p, const cl_I& l, const upvec& u, const vector<ex>& lcU)
2010 const size_t nu = I.size() + 1;
2011 const cl_modint_ring R = find_modint_ring(expt_pos(cl_I(p),l));
2016 for ( size_t j=nu; j>=2; --j ) {
2018 int alpha = I[j-2].evalpoint;
2019 A[j-2] = A[j-1].subs(x==alpha);
2020 A[j-2] = make_modular(A[j-2], R);
2023 int maxdeg = a.degree(I.front().x);
2024 for ( size_t i=1; i<I.size(); ++i ) {
2025 int maxdeg2 = a.degree(I[i].x);
2026 if ( maxdeg2 > maxdeg ) maxdeg = maxdeg2;
2029 const size_t n = u.size();
2031 for ( size_t i=0; i<n; ++i ) {
2032 U[i] = umodpoly_to_ex(u[i], x);
2035 for ( size_t j=2; j<=nu; ++j ) {
2038 for ( size_t m=0; m<n; ++m) {
2039 if ( lcU[m] != 1 ) {
2041 for ( size_t i=j-1; i<nu-1; ++i ) {
2042 coef = coef.subs(I[i].x == I[i].evalpoint);
2044 coef = make_modular(coef, R);
2045 int deg = U[m].degree(x);
2046 U[m] = U[m] - U[m].lcoeff(x) * pow(x,deg) + coef * pow(x,deg);
2050 for ( size_t i=0; i<n; ++i ) {
2053 ex e = expand(A[j-1] - Uprod);
2055 vector<EvalPoint> newI;
2056 for ( size_t i=1; i<=j-2; ++i ) {
2057 newI.push_back(I[i-1]);
2061 int alphaj = I[j-2].evalpoint;
2062 size_t deg = A[j-1].degree(xj);
2063 for ( size_t k=1; k<=deg; ++k ) {
2064 if ( !e.is_zero() ) {
2065 monomial *= (xj - alphaj);
2066 monomial = expand(monomial);
2067 ex dif = e.diff(ex_to<symbol>(xj), k);
2068 ex c = dif.subs(xj==alphaj) / factorial(k);
2069 if ( !c.is_zero() ) {
2070 vector<ex> deltaU = multivar_diophant(U1, x, c, newI, maxdeg, p, cl_I_to_uint(l));
2071 for ( size_t i=0; i<n; ++i ) {
2072 deltaU[i] *= monomial;
2074 U[i] = make_modular(U[i], R);
2077 for ( size_t i=0; i<n; ++i ) {
2081 e = make_modular(e, R);
2088 for ( size_t i=0; i<U.size(); ++i ) {
2091 if ( expand(a-acand).is_zero() ) {
2093 for ( size_t i=0; i<U.size(); ++i ) {
2104 /** Takes a factorized expression and puts the factors in a lst. The exponents
2105 * of the factors are discarded, e.g. 7*x^2*(y+1)^4 --> {7,x,y+1}. The first
2106 * element of the list is always the numeric coefficient.
2108 static ex put_factors_into_lst(const ex& e)
2111 if ( is_a<numeric>(e) ) {
2115 if ( is_a<power>(e) ) {
2117 result.append(e.op(0));
2120 if ( is_a<symbol>(e) || is_a<add>(e) ) {
2121 ex icont(e.integer_content());
2122 result.append(icont);
2123 result.append(e/icont);
2126 if ( is_a<mul>(e) ) {
2128 for ( size_t i=0; i<e.nops(); ++i ) {
2130 if ( is_a<numeric>(op) ) {
2133 if ( is_a<power>(op) ) {
2134 result.append(op.op(0));
2136 if ( is_a<symbol>(op) || is_a<add>(op) ) {
2140 result.prepend(nfac);
2143 throw runtime_error("put_factors_into_lst: bad term.");
2146 /** Checks a set of numbers for whether each number has a unique prime factor.
2148 * @param[in] f list of numbers to check
2149 * @return true: if number set is bad, false: if set is okay (has unique
2152 static bool checkdivisors(const lst& f)
2154 const int k = f.nops();
2156 vector<numeric> d(k);
2157 d[0] = ex_to<numeric>(abs(f.op(0)));
2158 for ( int i=1; i<k; ++i ) {
2159 q = ex_to<numeric>(abs(f.op(i)));
2160 for ( int j=i-1; j>=0; --j ) {
2175 /** Generates a set of evaluation points for a multivariate polynomial.
2176 * The set fulfills the following conditions:
2177 * 1. lcoeff(evaluated_polynomial) does not vanish
2178 * 2. factors of lcoeff(evaluated_polynomial) have each a unique prime factor
2179 * 3. evaluated_polynomial is square free
2180 * See [Wan] for more details.
2182 * @param[in] u multivariate polynomial to be factored
2183 * @param[in] vn leading coefficient of u in x (x==first symbol in syms)
2184 * @param[in] syms set of symbols that appear in u
2185 * @param[in] f lst containing the factors of the leading coefficient vn
2186 * @param[in,out] modulus integer modulus for random number generation (i.e. |a_i| < modulus)
2187 * @param[out] u0 returns the evaluated (univariate) polynomial
2188 * @param[out] a returns the valid evaluation points. must have initial size equal
2189 * number of symbols-1 before calling generate_set
2191 static void generate_set(const ex& u, const ex& vn, const exset& syms, const lst& f,
2192 numeric& modulus, ex& u0, vector<numeric>& a)
2194 const ex& x = *syms.begin();
2197 // generate a set of integers ...
2201 exset::const_iterator s = syms.begin();
2203 for ( size_t i=0; i<a.size(); ++i ) {
2205 a[i] = mod(numeric(rand()), 2*modulus) - modulus;
2206 vnatry = vna.subs(*s == a[i]);
2207 // ... for which the leading coefficient doesn't vanish ...
2208 } while ( vnatry == 0 );
2210 u0 = u0.subs(*s == a[i]);
2213 // ... for which u0 is square free ...
2214 ex g = gcd(u0, u0.diff(ex_to<symbol>(x)));
2215 if ( !is_a<numeric>(g) ) {
2218 if ( !is_a<numeric>(vn) ) {
2219 // ... and for which the evaluated factors have each an unique prime factor
2221 fnum.let_op(0) = fnum.op(0) * u0.content(x);
2222 for ( size_t i=1; i<fnum.nops(); ++i ) {
2223 if ( !is_a<numeric>(fnum.op(i)) ) {
2226 for ( size_t j=0; j<a.size(); ++j, ++s ) {
2227 fnum.let_op(i) = fnum.op(i).subs(*s == a[j]);
2231 if ( checkdivisors(fnum) ) {
2235 // ok, we have a valid set now
2240 // forward declaration
2241 static ex factor_sqrfree(const ex& poly);
2243 /** Multivariate factorization.
2245 * The implementation is based on the algorithm described in [Wan].
2246 * An evaluation homomorphism (a set of integers) is determined that fulfills
2247 * certain criteria. The evaluated polynomial is univariate and is factorized
2248 * by factor_univariate(). The main work then is to find the correct leading
2249 * coefficients of the univariate factors. They have to correspond to the
2250 * factors of the (multivariate) leading coefficient of the input polynomial
2251 * (as defined for a specific variable x). After that the Hensel lifting can be
2254 * @param[in] poly expanded, square free polynomial
2255 * @param[in] syms contains the symbols in the polynomial
2256 * @return factorized polynomial
2258 static ex factor_multivariate(const ex& poly, const exset& syms)
2260 exset::const_iterator s;
2261 const ex& x = *syms.begin();
2263 // make polynomial primitive
2265 poly.unitcontprim(x, unit, cont, pp);
2266 if ( !is_a<numeric>(cont) ) {
2267 return factor_sqrfree(cont) * factor_sqrfree(pp);
2270 // factor leading coefficient
2271 ex vn = pp.collect(x).lcoeff(x);
2273 if ( is_a<numeric>(vn) ) {
2277 ex vnfactors = factor(vn);
2278 vnlst = put_factors_into_lst(vnfactors);
2281 const unsigned int maxtrials = 3;
2282 numeric modulus = (vnlst.nops() > 3) ? vnlst.nops() : 3;
2283 vector<numeric> a(syms.size()-1, 0);
2285 // try now to factorize until we are successful
2288 unsigned int trialcount = 0;
2290 int factor_count = 0;
2291 int min_factor_count = -1;
2295 // try several evaluation points to reduce the number of factors
2296 while ( trialcount < maxtrials ) {
2298 // generate a set of valid evaluation points
2299 generate_set(pp, vn, syms, ex_to<lst>(vnlst), modulus, u, a);
2301 ufac = factor_univariate(u, x, prime);
2302 ufaclst = put_factors_into_lst(ufac);
2303 factor_count = ufaclst.nops()-1;
2304 delta = ufaclst.op(0);
2306 if ( factor_count <= 1 ) {
2310 if ( min_factor_count < 0 ) {
2312 min_factor_count = factor_count;
2314 else if ( min_factor_count == factor_count ) {
2318 else if ( min_factor_count > factor_count ) {
2319 // new minimum, reset trial counter
2320 min_factor_count = factor_count;
2325 // determine true leading coefficients for the Hensel lifting
2326 vector<ex> C(factor_count);
2327 if ( is_a<numeric>(vn) ) {
2329 for ( size_t i=1; i<ufaclst.nops(); ++i ) {
2330 C[i-1] = ufaclst.op(i).lcoeff(x);
2335 // we use the property of the ftilde having a unique prime factor.
2336 // details can be found in [Wan].
2338 vector<numeric> ftilde(vnlst.nops()-1);
2339 for ( size_t i=0; i<ftilde.size(); ++i ) {
2340 ex ft = vnlst.op(i+1);
2343 for ( size_t j=0; j<a.size(); ++j ) {
2344 ft = ft.subs(*s == a[j]);
2347 ftilde[i] = ex_to<numeric>(ft);
2349 // calculate D and C
2350 vector<bool> used_flag(ftilde.size(), false);
2351 vector<ex> D(factor_count, 1);
2353 for ( int i=0; i<factor_count; ++i ) {
2354 numeric prefac = ex_to<numeric>(ufaclst.op(i+1).lcoeff(x));
2355 for ( int j=ftilde.size()-1; j>=0; --j ) {
2357 while ( irem(prefac, ftilde[j]) == 0 ) {
2358 prefac = iquo(prefac, ftilde[j]);
2362 used_flag[j] = true;
2363 D[i] = D[i] * pow(vnlst.op(j+1), count);
2366 C[i] = D[i] * prefac;
2370 for ( int i=0; i<factor_count; ++i ) {
2371 numeric prefac = ex_to<numeric>(ufaclst.op(i+1).lcoeff(x));
2372 for ( int j=ftilde.size()-1; j>=0; --j ) {
2374 while ( irem(prefac, ftilde[j]) == 0 ) {
2375 prefac = iquo(prefac, ftilde[j]);
2378 while ( irem(ex_to<numeric>(delta)*prefac, ftilde[j]) == 0 ) {
2379 numeric g = gcd(prefac, ex_to<numeric>(ftilde[j]));
2380 prefac = iquo(prefac, g);
2381 delta = delta / (ftilde[j]/g);
2382 ufaclst.let_op(i+1) = ufaclst.op(i+1) * (ftilde[j]/g);
2386 used_flag[j] = true;
2387 D[i] = D[i] * pow(vnlst.op(j+1), count);
2390 C[i] = D[i] * prefac;
2393 // check if something went wrong
2394 bool some_factor_unused = false;
2395 for ( size_t i=0; i<used_flag.size(); ++i ) {
2396 if ( !used_flag[i] ) {
2397 some_factor_unused = true;
2401 if ( some_factor_unused ) {
2406 // multiply the remaining content of the univariate polynomial into the
2409 C[0] = C[0] * delta;
2410 ufaclst.let_op(1) = ufaclst.op(1) * delta;
2413 // set up evaluation points
2415 vector<EvalPoint> epv;
2418 for ( size_t i=0; i<a.size(); ++i ) {
2420 ep.evalpoint = a[i].to_int();
2426 for ( int i=1; i<=factor_count; ++i ) {
2427 if ( ufaclst.op(i).degree(x) > maxdeg ) {
2428 maxdeg = ufaclst[i].degree(x);
2431 cl_I B = 2*calc_bound(u, x, maxdeg);
2439 // set up modular factors (mod p^l)
2440 cl_modint_ring R = find_modint_ring(expt_pos(cl_I(prime),l));
2441 upvec modfactors(ufaclst.nops()-1);
2442 for ( size_t i=1; i<ufaclst.nops(); ++i ) {
2443 umodpoly_from_ex(modfactors[i-1], ufaclst.op(i), x, R);
2446 // try Hensel lifting
2447 ex res = hensel_multivar(pp, x, epv, prime, l, modfactors, C);
2448 if ( res != lst() ) {
2449 ex result = cont * unit;
2450 for ( size_t i=0; i<res.nops(); ++i ) {
2451 result *= res.op(i).content(x) * res.op(i).unit(x);
2452 result *= res.op(i).primpart(x);
2459 /** Finds all symbols in an expression. Used by factor_sqrfree() and factor().
2461 struct find_symbols_map : public map_function {
2463 ex operator()(const ex& e)
2465 if ( is_a<symbol>(e) ) {
2469 return e.map(*this);
2473 /** Factorizes a polynomial that is square free. It calls either the univariate
2474 * or the multivariate factorization functions.
2476 static ex factor_sqrfree(const ex& poly)
2478 // determine all symbols in poly
2479 find_symbols_map findsymbols;
2481 if ( findsymbols.syms.size() == 0 ) {
2485 if ( findsymbols.syms.size() == 1 ) {
2487 const ex& x = *(findsymbols.syms.begin());
2488 if ( poly.ldegree(x) > 0 ) {
2489 // pull out direct factors
2490 int ld = poly.ldegree(x);
2491 ex res = factor_univariate(expand(poly/pow(x, ld)), x);
2492 return res * pow(x,ld);
2495 ex res = factor_univariate(poly, x);
2500 // multivariate case
2501 ex res = factor_multivariate(poly, findsymbols.syms);
2505 /** Map used by factor() when factor_options::all is given to access all
2506 * subexpressions and to call factor() on them.
2508 struct apply_factor_map : public map_function {
2510 apply_factor_map(unsigned options_) : options(options_) { }
2511 ex operator()(const ex& e)
2513 if ( e.info(info_flags::polynomial) ) {
2514 return factor(e, options);
2516 if ( is_a<add>(e) ) {
2518 for ( size_t i=0; i<e.nops(); ++i ) {
2519 if ( e.op(i).info(info_flags::polynomial) ) {
2528 return factor(s1, options) + s2.map(*this);
2530 return e.map(*this);
2534 } // anonymous namespace
2536 /** Interface function to the outside world. It checks the arguments, tries a
2537 * square free factorization, and then calls factor_sqrfree to do the hard
2540 ex factor(const ex& poly, unsigned options)
2543 if ( !poly.info(info_flags::polynomial) ) {
2544 if ( options & factor_options::all ) {
2545 options &= ~factor_options::all;
2546 apply_factor_map factor_map(options);
2547 return factor_map(poly);
2552 // determine all symbols in poly
2553 find_symbols_map findsymbols;
2555 if ( findsymbols.syms.size() == 0 ) {
2559 exset::const_iterator i=findsymbols.syms.begin(), end=findsymbols.syms.end();
2560 for ( ; i!=end; ++i ) {
2564 // make poly square free
2565 ex sfpoly = sqrfree(poly.expand(), syms);
2567 // factorize the square free components
2568 if ( is_a<power>(sfpoly) ) {
2569 // case: (polynomial)^exponent
2570 const ex& base = sfpoly.op(0);
2571 if ( !is_a<add>(base) ) {
2572 // simple case: (monomial)^exponent
2575 ex f = factor_sqrfree(base);
2576 return pow(f, sfpoly.op(1));
2578 if ( is_a<mul>(sfpoly) ) {
2579 // case: multiple factors
2581 for ( size_t i=0; i<sfpoly.nops(); ++i ) {
2582 const ex& t = sfpoly.op(i);
2583 if ( is_a<power>(t) ) {
2584 const ex& base = t.op(0);
2585 if ( !is_a<add>(base) ) {
2589 ex f = factor_sqrfree(base);
2590 res *= pow(f, t.op(1));
2593 else if ( is_a<add>(t) ) {
2594 ex f = factor_sqrfree(t);
2603 if ( is_a<symbol>(sfpoly) ) {
2606 // case: (polynomial)
2607 ex f = factor_sqrfree(sfpoly);
2611 } // namespace GiNaC